Petar Karan

[moodle] Applicare il consenso utente in massa a degli utenti selezionati per indirizzo email o altro criterio

Scenario: Vogliamo impostare il consenso al trattamento dei dati per un gruppo di utenti iscritti su Moodle, che vogliamo selezionare in base al dominio dell’indirizzo e-mail

Problema: Dalla sezione admin/tool/policy/acceptances.php purtroppo non è possibile filtrare gli utenti in base all’indirizzo email (è possibile solo ordinarli) e quindi se dobbiamo selezionare molti utenti l’operazione risulta lenta

Per risolvere il problema possiamo eseguire la seguente query direttamente sul database.

Prima di eseguirla assicurarsi che per gli utenti che si intendono selezionare, non ci siano già dei consensi accettati e di conseguenza dei record nella tabella.

INSERT INTO mdl_tool_policy_acceptances (`policyversionid`, `userid`, `status`, `lang`, `usermodified`, `timecreated`, `timemodified`, `note`)
SELECT 2, u.id, 1, 'it', u.id, UNIX_TIMESTAMP(), UNIX_TIMESTAMP(), NULL
FROM mdl_user u
WHERE u.email LIKE '%@dominio.it' AND u.id NOT IN (1001,1002);

INSERT INTO mdl_tool_policy_acceptances (`policyversionid`, `userid`, `status`, `lang`, `usermodified`, `timecreated`, `timemodified`, `note`)

SELECT 2, u.id, 1, 'it', u.id, UNIX_TIMESTAMP(), UNIX_TIMESTAMP(), NULL

FROM mdl_user u

WHERE u.email LIKE '%@dominio.it' AND u.id NOT IN (1001,1002);

In questo caso stiamo escludendo, dall’aggiunta, gli utenti il cui ID è il 1001 e il 1002, perché abbiamo verificato che hanno già dei record nella tabella mdl_tool_policy_acceptances

Alcune note importanti:

policyversionid dev’essere impostato sulla versione della policy che si vuole accettare, di predefinito sarebbe 1, qui abbiamo messo 2 supponendo di avere due policy
usermodified qui lo abbiamo messo identico all’utente che stiamo modificando, in linea di principio andrebbe associato all’utente di un responsabile per la privacy
note lo abbiamo lasciato vuoto, di solito si potrebbe segnare qui la nota che siamo noi ad apportare la modifica

Se non ci sono utenti da escludere, rimuovere la parte finale della query, che diventerebbe così:

INSERT INTO mdl_tool_policy_acceptances (`policyversionid`, `userid`, `status`, `lang`, `usermodified`, `timecreated`, `timemodified`, `note`) 
SELECT 2, u.id, 1, 'it', u.id, UNIX_TIMESTAMP(), UNIX_TIMESTAMP(), NULL 
FROM mdl_user u 
WHERE u.email LIKE '%@dominio.it'

INSERT INTO mdl_tool_policy_acceptances (`policyversionid`, `userid`, `status`, `lang`, `usermodified`, `timecreated`, `timemodified`, `note`)

SELECT 2, u.id, 1, 'it', u.id, UNIX_TIMESTAMP(), UNIX_TIMESTAMP(), NULL

FROM mdl_user u

WHERE u.email LIKE '%@dominio.it'

[excel] Risolvere il problema della somma di sottoinsiemi con il calcolo matriciale

Immaginiamo di avere una tabella con codici e importi e si voglia trovare la combinazione di codici la somma dei cui importi dia un importo cercato. Questo problema in informatica è noto come la ricerca della somma dei sottoinsiemi.

Prima di cominciare sottolineo che questa soluzione è pensata per Microsoft Office 365, che include le più recenti funzionalità di Excel che non sono disponibili in versioni precedenti.

Abbiamo quindi una tabella di codici e importi come la seguente:

E vogliamo permettere che si possa inserire un valore e trovare una combinazione di codici validi:

In questo caso abbiamo messo 1.400 e la combinazione dei codici F006 e H008 dà effettivamente come somma 1.400€

NOTA BENE: potrebbero esserci molteplici combinazioni che soddisfano lo stesso criterio, noi ne cerchiamo almeno 1

Anzitutto dobbiamo risolvere il problema di creare una lista (in realtà una matrice) di tutte le possibili combinazioni. Partiamo analizzando il problema nel modo più semplice: se avessimo solo tre elementi (chiamiamoli A, B e C) quante combinazioni potremmo avere?

Ad esempio potremmo avere ABC insieme, oppure solo AB o BC oppure AC, ecc. Come possiamo far fare questo calcolo a Excel? Ci può venire in aiuto la notazione binaria, dove vogliamo prendere tutti i numeri da 000 a 111 (che corrisponde a 7). Il numero 111 (ossia 7 in decimale) è l’ultimo numero di 2^3 – 1 (dove 3 è il numero di elementi). Potremmo quindi creare una lista binaria come la seguente:

0 = 000
1 = 001
2 = 010
3 = 011
4 = 100
5 = 101
6 = 110
7 = 111

Questo lo possiamo ottenere con la formula:

=DECIMALE.BINARIO(RIF.RIGA(INDIRETTO("1:"&(2^3)))-1;3)

1	=DECIMALE.BINARIO(RIF.RIGA(INDIRETTO("1:"&(2^3)))-1;3)

Il risultato sarà qualcosa del genere:

Per trasporre questi valori in riga scriviamo:

=DECIMALE.BINARIO(MATR.TRASPOSTA(RIF.RIGA(INDIRETTO("1:"&(2^3)))-1);3)

1	=DECIMALE.BINARIO(MATR.TRASPOSTA(RIF.RIGA(INDIRETTO("1:"&(2^3)))-1);3)

A questo punto abbiamo una matrice di 1 riga e 8 colonne, ossia 1×8. Al prossimo passaggio voglio estendere la cosa a n = 5 elementi anziché n = 3. Inoltre voglio separare le singole combinazioni in righe, su ciascuna colonna. In questo modo avremo una matrice 5×32 (5 righe per 32 colonne).

=STRINGA.ESTRAI(DECIMALE.BINARIO(MATR.TRASPOSTA(RIF.RIGA(INDIRETTO("1:"&(2^5)))-1);5);RIF.RIGA(1:5);1)

1	=STRINGA.ESTRAI(DECIMALE.BINARIO(MATR.TRASPOSTA(RIF.RIGA(INDIRETTO("1:"&(2^5)))-1);5);RIF.RIGA(1:5);1)

Il risultato (in espansione) sarà simile a questo:

Adesso ci basta moltiplicare la matrice 5×1 (una colonna di valori, ricordiamoci che ora ne stiamo prendendo solo 5) per la matrice ottenuta in precedenza:

=STRINGA.ESTRAI(DECIMALE.BINARIO(MATR.TRASPOSTA(RIF.RIGA(INDIRETTO("1:"&(2^5)))-1);5);RIF.RIGA(1:5);1)*G8:G12

1	=STRINGA.ESTRAI(DECIMALE.BINARIO(MATR.TRASPOSTA(RIF.RIGA(INDIRETTO("1:"&(2^5)))-1);5);RIF.RIGA(1:5);1)*G8:G12

Dove G8:G12 sono gli importi in questo modo:

Otterremo così un risultato come il seguente:

A questo punto abbiamo tutte le possibili combinazioni di valori.

Adesso si presenta il problema più complesso, ossia ridurre questa matrice da 5×32 a 1×32, praticamente una riga con valori uguali alla somma delle colonne della precedente matrice. Per ottenere questo risultato usiamo la funzione PERCOL (introdotta recentemente).

=PERCOL(STRINGA.ESTRAI(DECIMALE.BINARIO(MATR.TRASPOSTA(RIF.RIGA(INDIRETTO("1:"&(2^5)))-1);5);RIF.RIGA(1:5);1)*G8:G12;SOMMA)

1	=PERCOL(STRINGA.ESTRAI(DECIMALE.BINARIO(MATR.TRASPOSTA(RIF.RIGA(INDIRETTO("1:"&(2^5)))-1);5);RIF.RIGA(1:5);1)*G8:G12;SOMMA)

PERCOL accetta una funzione come secondo argomento, in questo caso applichiamo la funzione SOMMA.

Quello che otteniamo è un risultato simile a questo:

Adesso possiamo essere più felici che mai perché siamo ad un passo dalla soluzione. Ci basta costruire, in modo analogo la matrice con la concatenazione dei codici corrispondenti alle somme.

Per farlo applichiamo la funzione SE alla solita matrice binaria che abbiamo generato prima:

=SE(STRINGA.ESTRAI(DECIMALE.BINARIO(MATR.TRASPOSTA(RIF.RIGA(INDIRETTO("1:"&(2^5)))-1);5);RIF.RIGA(1:5);1)="1";F8:F12;"")

1	=SE(STRINGA.ESTRAI(DECIMALE.BINARIO(MATR.TRASPOSTA(RIF.RIGA(INDIRETTO("1:"&(2^5)))-1);5);RIF.RIGA(1:5);1)="1";F8:F12;"")

Dove l’intervallo F8:F12 è l’intervallo dei codici:

Usiamo di nuovo PERCOL, questa volta con la funzione MATRICE.A.TESTO.

=PERCOL(SE(STRINGA.ESTRAI(DECIMALE.BINARIO(MATR.TRASPOSTA(RIF.RIGA(INDIRETTO("1:"&(2^5)))-1);5);RIF.RIGA(1:5);1)="1";F8:F12;"");MATRICE.A.TESTO)

1	=PERCOL(SE(STRINGA.ESTRAI(DECIMALE.BINARIO(MATR.TRASPOSTA(RIF.RIGA(INDIRETTO("1:"&(2^5)))-1);5);RIF.RIGA(1:5);1)="1";F8:F12;"");MATRICE.A.TESTO)

E così abbiamo la sequenza di tutti i possibili codici. Non ci resta che utilizzare CERCA.X per cercare nella matrice degli importi e prendere l’equivalente combinazione di codici:

=CERCA.X(G18;PERCOL(STRINGA.ESTRAI(DECIMALE.BINARIO(MATR.TRASPOSTA(RIF.RIGA(INDIRETTO("1:"&(2^CONTA.VALORI(F8:F15))))-1);CONTA.VALORI(F8:F15));RIF.RIGA(INDIRETTO("1:"&CONTA.VALORI(F8:F15)));1)*G8:G15;SOMMA);PERCOL(SE(STRINGA.ESTRAI(DECIMALE.BINARIO(MATR.TRASPOSTA(RIF.RIGA(INDIRETTO("1:"&(2^CONTA.VALORI(F8:F15))))-1);CONTA.VALORI(F8:F15));RIF.RIGA(INDIRETTO("1:"&CONTA.VALORI(F8:F15)));1)="1";F8:F15;"");MATRICE.A.TESTO);"non trovato";0;1)

=CERCA.X(G18;PERCOL(STRINGA.ESTRAI(DECIMALE.BINARIO(MATR.TRASPOSTA(RIF.RIGA(INDIRETTO("1:"&(2^CONTA.VALORI(F8:F15))))-1);CONTA.VALORI(F8:F15));RIF.RIGA(INDIRETTO("1:"&CONTA.VALORI(F8:F15)));1)*G8:G15;SOMMA);PERCOL(SE(STRINGA.ESTRAI(DECIMALE.BINARIO(MATR.TRASPOSTA(RIF.RIGA(INDIRETTO("1:"&(2^CONTA.VALORI(F8:F15))))-1);CONTA.VALORI(F8:F15));RIF.RIGA(INDIRETTO("1:"&CONTA.VALORI(F8:F15)));1)="1";F8:F15;"");MATRICE.A.TESTO);"non trovato";0;1)

Questa volta estendiamo gli intervalli a tutti i codici e gli importi, nel modo seguente:

Cambiando l’ultimo parametro, la modalità di ricerca, possiamo decidere se farla a partire dal primo o dall’ultimo valore trovato.

[kotlin] Disegnare matrice concentrica in Python data una dimensione arbitraria (e valutare le prestazioni)

Similmente a quanto abbiamo fatto con Python, vogliamo scrivere un algoritmo in Kotlin che, dato un lato n-esimo arbitrario, disegni una matrice di valori concentrici. Il risultato che vogliamo ottenere è il seguente:

Anche in questo caso vogliamo misurare il tempo di calcolo per ognuno dei metodi adottati. L’algoritmo può essere affrontato in molti modi, similmente a quanto abbiamo fatto con Python, quindi in questo caso mi limiterò a due casi soltanto, con le relative valutazioni di velocità.

Cominciamo con il primo metodo, che è anche quello più semplice e meno efficiente.

Definiamo quindi una funzione che ci permetta di scegliere se acquisire l’input dall’utente oppure passarlo noi programmaticamente (e analogamente che consenta di scegliere se stamparlo o meno a video).

fun metodo1(stampa: Boolean = true, ndefault: Int = 0) : Double {

    println("-- disegna quadrato concentrico --")
    if( ndefault == 0 ) print("Lato quadrato: ")
    val n = if( ndefault == 0 ) readln().toInt() else ndefault
    val dim = n * 2 - 1

    val quadrato = Array(dim) { IntArray(dim) }

    val inizio = System.nanoTime() // tempo in nanosecondi

    for( k in 0 .. n-1 ) {
        for( i in k .. dim - k - 1 ) {
            for( j in k .. dim - k - 1 ) {
                quadrato[i][j] = n - k
            }
        }
    }

    val fine = System.nanoTime()

    println("Tempo metodo1: ${(fine - inizio) / 1_000_000.0} ms")

    // stampa del quadrato
    if( stampa ) {
        for (i in quadrato.indices) {
            for (j in quadrato[i].indices) {
                print("${quadrato[i][j]} ")
            }
            println()
        }
    }

    return (fine - inizio) / 1_000_000.0

}

fun metodo1(stampa: Boolean = true, ndefault: Int = 0) : Double {

println("-- disegna quadrato concentrico --")

if( ndefault == 0 ) print("Lato quadrato: ")

val n = if( ndefault == 0 ) readln().toInt() else ndefault

val dim = n * 2 - 1

val quadrato = Array(dim) { IntArray(dim) }

val inizio = System.nanoTime() // tempo in nanosecondi

for( k in 0 .. n-1 ) {

for( i in k .. dim - k - 1 ) {

for( j in k .. dim - k - 1 ) {

quadrato[i][j] = n - k

}

val fine = System.nanoTime()

println("Tempo metodo1: ${(fine - inizio) / 1_000_000.0} ms")

// stampa del quadrato

if( stampa ) {

for (i in quadrato.indices) {

for (j in quadrato[i].indices) {

print("${quadrato[i][j]} ")

}

println()

}

return (fine - inizio) / 1_000_000.0

}

Per eseguirlo lo chiamiamo dentro il main.

fun main() {

    metodo1()

}

fun main() {

metodo1()

}

Nel secondo metodo avremo bisogno di definire un oggetto di appoggio per le variabili che vogliamo usare globalmente:

object Globale {
    var dim: Int = 0
    var n: Int = 0
}

object Globale {

var dim: Int = 0

var n: Int = 0

}

E creiamo una funzione di calcolo dei valori:

fun calcolaValore(i: Int, j: Int) : Int {
    val ni = if( i < Globale.dim / 2.0 ) i else Globale.dim - i - 1
    val nj = if( j < Globale.dim / 2.0 ) j else Globale.dim - j - 1
    return Globale.n - ( if( nj <= ni ) nj else ni )
}

fun calcolaValore(i: Int, j: Int) : Int {

val ni = if( i < Globale.dim / 2.0 ) i else Globale.dim - i - 1

val nj = if( j < Globale.dim / 2.0 ) j else Globale.dim - j - 1

return Globale.n - ( if( nj <= ni ) nj else ni )

}

Procediamo alla creazione della seconda funzione:

fun metodo2(stampa : Boolean = true, ndefault : Int = 0) : Double {

    println("-- disegna quadrato concentrico --")
    if( ndefault == 0 ) print("Lato quadrato: ")
    val n = if( ndefault == 0 ) readln().toInt() else ndefault
    val dim = n * 2 - 1

    Globale.dim = dim
    Globale.n = n

    val quadrato = Array(dim) { IntArray(dim) }

    val inizio = System.nanoTime() // tempo in nanosecondi

    for( i in quadrato.indices ) {
        for( j in quadrato[i].indices ) {
            quadrato[i][j] = calcolaValore(i, j)
        }
    }

    val fine = System.nanoTime()

    println("Tempo metodo2: ${(fine - inizio) / 1_000_000.0} ms")

    // stampa del quadrato
    if( stampa ) {
        for (i in quadrato.indices) {
            for (j in quadrato[i].indices) {
                print("${quadrato[i][j]} ")
            }
            println()
        }
    }

    return (fine - inizio) / 1_000_000.0

}

fun metodo2(stampa : Boolean = true, ndefault : Int = 0) : Double {

println("-- disegna quadrato concentrico --")

if( ndefault == 0 ) print("Lato quadrato: ")

val n = if( ndefault == 0 ) readln().toInt() else ndefault

val dim = n * 2 - 1

Globale.dim = dim

Globale.n = n

val quadrato = Array(dim) { IntArray(dim) }

val inizio = System.nanoTime() // tempo in nanosecondi

for( i in quadrato.indices ) {

for( j in quadrato[i].indices ) {

quadrato[i][j] = calcolaValore(i, j)

}

val fine = System.nanoTime()

println("Tempo metodo2: ${(fine - inizio) / 1_000_000.0} ms")

// stampa del quadrato

if( stampa ) {

for (i in quadrato.indices) {

for (j in quadrato[i].indices) {

print("${quadrato[i][j]} ")

}

println()

}

return (fine - inizio) / 1_000_000.0

}

Mettiamo alla prova entrambi i metodi:

fun main() {

    metodo1(false, 10)
    metodo2(false, 10)

}

fun main() {

metodo1(false, 10)

metodo2(false, 10)

}

Su un quadrato con n = 10 il primo metodo risulta più efficiente del secondo:

-- disegna quadrato concentrico --
Tempo metodo1: 0.0121 ms
-- disegna quadrato concentrico --
Tempo metodo2: 0.0553 ms

-- disegna quadrato concentrico --

Tempo metodo1: 0.0121 ms

-- disegna quadrato concentrico --

Tempo metodo2: 0.0553 ms

Proviamo ad alzare il tiro impostando n = 1000

-- disegna quadrato concentrico --
Tempo metodo1: 425.644 ms
-- disegna quadrato concentrico --
Tempo metodo2: 10.637 ms

-- disegna quadrato concentrico --

Tempo metodo1: 425.644 ms

-- disegna quadrato concentrico --

Tempo metodo2: 10.637 ms

Raccogliamo un po’ di dati per valori di n rispettivamente impostati a 10, 100, 1.000, 10.000 e 20.000:

fun main() {

    for( i in listOf(10,100,1_000,10_000,20_000) ) {
        val r1 = metodo1(false, i)
        val r2 = metodo2(false, i)
        println("$i;$r1;$r2")
    }

}

fun main() {

for( i in listOf(10,100,1_000,10_000,20_000) ) {

val r1 = metodo1(false, i)

val r2 = metodo2(false, i)

println("$i;$r1;$r2")

}

Nel caso in si dovesse incorrere nell’errore Exception in thread "main" java.lang.OutOfMemoryError: Java heap space aumentare lo spazio del Shared heap size in Settings -> Build, Execution, Deployment -> Compiler

Oppure creare una configurazione personalizzata per il compilatore come per esempio questa:

Comunque sia otterremo così i seguenti dati:

n	metodo1	metodo2
10	0,0103	0,0558
100	2,608	1,032
1000	368,7968	7,4704
10000	324428,347	206,1374
20000	2797371,15	1589,187

Al crescere della complessità del sistema vediamo come cresce il rapporto tra il metodo1 e il metodo2

[python] Semplice programma per rimuovere la protezione dai file Word

Vogliamo automatizzare il processo di rimozione della protezione dai file Word utilizzando il nostro amato Python. Questo articolo si ricollega al procedimento già illustrato in precedenza in [word] Rimuovere “Limita modifica” da un file docx di Word

Per i dettagli della procedura rimando all’articolo precedente, qui vedremo esclusivamente la parte che riguarda Python.

In Python vogliamo realizzare uno script che permetta o dal prompt dei comandi, oppure trascinandoci sopra un file, di sbloccare un file Word al quale sia applicata la protezione contro le modifiche.

Quello che vogliamo ottenere alla fine è qualcosa di simile:

Oppure un eseguibile sopra il quale sia possibile trascinare il file da sbloccare.

Seguono i commenti nel codice:

import sys
import zipfile
import os
import shutil

# costruiamo il main
def main():

    # in caso di un qualsiasi errore non gestito
    try:

        # controlliamo se c'è il secondo argomento, ricordando che gli argomenti sono:
        # 0 - nome dello script o dell'eseguibile
        # 1 - primo argomento, in questo caso il percorso del file
        # la lunghezza quindi degli argomenti passati dev'essere almeno 2
        if len(sys.argv) < 2:
            print("Trascina un file sull'eseguibile")
            return

        # se c'è il secondo argomento supponiamo che sia il percorso al file
        else:
            # preleviamo il percorso al file
            file_path = sys.argv[1]
            print(f"Percorso del file: {file_path}")
            print("Inizio modifica file...")

            # definiamo una cartella temporanea per l'estrazione
            temp_dir = "temp_extract"

            try:
                # creiamo tale cartella, se già esiste andiamo avanti
                os.makedirs(temp_dir, exist_ok=True)
            except:
                print("Errore 1: impossibile creare cartella, permesso negato")
                return

            try:
                # estraiamo tutto il file docx, trattandolo come se fosse un file zip
                # ricordiamoci che a tutti gli effetti è un file zip rinominato
                with zipfile.ZipFile(file_path, 'r') as fp:
                    fp.extractall(temp_dir)
            except:
                print("Errore 2: impossibile scompattare!")
                return

            # in ogni file word corretto dovrà essere il file settings.xml che andremo a modificare
            xml_file = "temp_extract/word/settings.xml"

            try:
                # apriamo il file xml e leggiamo tutto il contenuto
                with open(xml_file,'r') as fp:
                    contenuto = fp.read()

                # sostituiamo il parametro enforcement impostandolo su false
                # ricordiamoci che il parametro può comparire configurato o come true o come 1
                # quindi tentiamo entrambe le sostituzioni, ovviamente avremmo potuto usare
                # la librerira xml, oppure un riconoscimento con stringhe regolari, ma perché
                # scomodarsi se possiamo fare le cose in modo bovino?
                contenuto = contenuto.replace('w:enforcement="true"','w:enforcement="false"')
                contenuto = contenuto.replace('w:enforcement="1"','w:enforcement="false"')

                # riscriviamo il file xml
                with open(xml_file,'w') as fp:
                    fp.write(contenuto)

                print("Chiusura file modificato...")
            except:
                print("Errore 3: impossibile modificare il file!")
                return

            # predisponiamo il nome del file sbloccato
            file_name = "sbloccato-" + os.path.basename(file_path)

            try:
                # ricreiamo tutto il file zip di prima, con il nuovo nome, applicando la compressione
                # ATTENZIONE: senza il parametro di compressione il file risultante potrebbe essere
                # molto più grande di quello di partenza (circa 10x)
                with zipfile.ZipFile(file_name,'w', compression=zipfile.ZIP_DEFLATED) as fp:
                    # percorriamo le cartelle in cerca di file
                    for root, _, files in os.walk(temp_dir):
                        # per ogni file che troviamo
                        for file in files:
                            # creiamo il percorso del file
                            fpath = os.path.join(root,file)
                            # prendiamo il percorso reale
                            arcname = os.path.relpath(fpath,temp_dir)
                            # aggiungiamo il file allo zip
                            fp.write(fpath, arcname)
            except:
                print("Errore 4: impossibile ricomporre!")
                return

            try:
                # cancelliamo la cartella temporanea, usando shutil possiamo rimuovere tutta la cartella
                # anche se dentro ci sono altri file e cartelle, cosa che os.rmdir non permette di fare
                shutil.rmtree(temp_dir)
            except Exception as e:
                print(f"Errore 5: impossibile pulire! {e}")
                return

            print("File modificato con successo in: %s" % file_name)
            
    except:
        print("Errore 0: impossibile eseguire")

if __name__ == "__main__":

    print("WordUnlocker v1.0.0")

    # eseguiamo il file main
    main()

    # questo ci serve solo per tenere aperto il prompt quanto basta per informare l'utente
    # alla pressione di INVIO il programma effettivamente terminerà
    scelta = input("Premi invio per chiudere...")

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

import sys

import zipfile

import os

import shutil

# costruiamo il main

def main():

# in caso di un qualsiasi errore non gestito

try:

# controlliamo se c'è il secondo argomento, ricordando che gli argomenti sono:

# 0 - nome dello script o dell'eseguibile

# 1 - primo argomento, in questo caso il percorso del file

# la lunghezza quindi degli argomenti passati dev'essere almeno 2

if len(sys.argv) < 2:

print("Trascina un file sull'eseguibile")

return

# se c'è il secondo argomento supponiamo che sia il percorso al file

else:

# preleviamo il percorso al file

file_path = sys.argv[1]

print(f"Percorso del file: {file_path}")

print("Inizio modifica file...")

# definiamo una cartella temporanea per l'estrazione

temp_dir = "temp_extract"

try:

# creiamo tale cartella, se già esiste andiamo avanti

os.makedirs(temp_dir, exist_ok=True)

except:

print("Errore 1: impossibile creare cartella, permesso negato")

return

try:

# estraiamo tutto il file docx, trattandolo come se fosse un file zip

# ricordiamoci che a tutti gli effetti è un file zip rinominato

with zipfile.ZipFile(file_path, 'r') as fp:

fp.extractall(temp_dir)

except:

print("Errore 2: impossibile scompattare!")

return

# in ogni file word corretto dovrà essere il file settings.xml che andremo a modificare

xml_file = "temp_extract/word/settings.xml"

try:

# apriamo il file xml e leggiamo tutto il contenuto

with open(xml_file,'r') as fp:

contenuto = fp.read()

# sostituiamo il parametro enforcement impostandolo su false

# ricordiamoci che il parametro può comparire configurato o come true o come 1

# quindi tentiamo entrambe le sostituzioni, ovviamente avremmo potuto usare

# la librerira xml, oppure un riconoscimento con stringhe regolari, ma perché

# scomodarsi se possiamo fare le cose in modo bovino?

contenuto = contenuto.replace('w:enforcement="true"','w:enforcement="false"')

contenuto = contenuto.replace('w:enforcement="1"','w:enforcement="false"')

# riscriviamo il file xml

with open(xml_file,'w') as fp:

fp.write(contenuto)

print("Chiusura file modificato...")

except:

print("Errore 3: impossibile modificare il file!")

return

# predisponiamo il nome del file sbloccato

file_name = "sbloccato-" + os.path.basename(file_path)

try:

# ricreiamo tutto il file zip di prima, con il nuovo nome, applicando la compressione

# ATTENZIONE: senza il parametro di compressione il file risultante potrebbe essere

# molto più grande di quello di partenza (circa 10x)

with zipfile.ZipFile(file_name,'w', compression=zipfile.ZIP_DEFLATED) as fp:

# percorriamo le cartelle in cerca di file

for root, _, files in os.walk(temp_dir):

# per ogni file che troviamo

for file in files:

# creiamo il percorso del file

fpath = os.path.join(root,file)

# prendiamo il percorso reale

arcname = os.path.relpath(fpath,temp_dir)

# aggiungiamo il file allo zip

fp.write(fpath, arcname)

except:

print("Errore 4: impossibile ricomporre!")

return

try:

# cancelliamo la cartella temporanea, usando shutil possiamo rimuovere tutta la cartella

# anche se dentro ci sono altri file e cartelle, cosa che os.rmdir non permette di fare

shutil.rmtree(temp_dir)

except Exception as e:

print(f"Errore 5: impossibile pulire! {e}")

return

print("File modificato con successo in: %s" % file_name)

except:

print("Errore 0: impossibile eseguire")

if __name__ == "__main__":

print("WordUnlocker v1.0.0")

# eseguiamo il file main

main()

# questo ci serve solo per tenere aperto il prompt quanto basta per informare l'utente

# alla pressione di INVIO il programma effettivamente terminerà

scelta = input("Premi invio per chiudere...")

Una volta scritto il codice in un file WordUnlocker.py salviamo il tutto e procediamo a creare il file eseguibile.

Per creare l’eseguibile utilizziamo pyinstaller. Possiamo installarlo utilizzando il comando PIP:

pip install -U pyinstaller

1	pip install -U pyinstaller

Dobbiamo preparare un file di versione che chiameremo file_version_info.txt, che sarà strutturato nel modo seguente:

VSVersionInfo(
  ffi=FixedFileInfo(
    filevers=(1, 0, 0, 0),
    prodvers=(1, 0, 0, 0),
    mask=0x3f,
    flags=0x0,
    OS=0x40004,
    fileType=0x1,
    subtype=0x0,
    date=(0, 0)
    ),
  kids=[
    StringFileInfo(
      [
      StringTable(
        u'040904B0',
        [StringStruct(u'CompanyName', u'Petar Karan'),
        StringStruct(u'FileDescription', u'MS Office Word Unlocker'),
        StringStruct(u'FileVersion', u'1.0.0.0 (20 febbraio 2025)'),
        StringStruct(u'InternalName', u'wordunlocker'),
        StringStruct(u'LegalCopyright', u'\xa9 Petar Karan. All rights reserved. https://petarkaran.it/'),
        StringStruct(u'OriginalFilename', u'WordUnlocker.exe'),
        StringStruct(u'ProductName', u'Word Unlocker'),
        StringStruct(u'ProductVersion', u'1.0.0.0')])
      ]), 
    VarFileInfo([VarStruct(u'Translation', [1033, 1200])])
  ]
)

VSVersionInfo(

ffi=FixedFileInfo(

filevers=(1, 0, 0, 0),

prodvers=(1, 0, 0, 0),

mask=0x3f,

flags=0x0,

OS=0x40004,

fileType=0x1,

subtype=0x0,

date=(0, 0)

kids=[

StringFileInfo(

[

StringTable(

u'040904B0',

[StringStruct(u'CompanyName', u'Petar Karan'),

StringStruct(u'FileDescription', u'MS Office Word Unlocker'),

StringStruct(u'FileVersion', u'1.0.0.0 (20 febbraio 2025)'),

StringStruct(u'InternalName', u'wordunlocker'),

StringStruct(u'OriginalFilename', u'WordUnlocker.exe'),

StringStruct(u'ProductName', u'Word Unlocker'),

StringStruct(u'ProductVersion', u'1.0.0.0')])

]),

VarFileInfo([VarStruct(u'Translation', [1033, 1200])])

]

)

Adesso possiamo compilare l’eseguibile con il seguente commando eseguito dal terminale sulla cartella del file di Python:

pyinstaller --clean --onefile .\WordUnlocker.py -i wordunlocker.png --version-file file_version_info.txt

1	pyinstaller --clean --onefile .\WordUnlocker.py -i wordunlocker.png --version-file file_version_info.txt

Fatto tutto questo non ci rimane che firmare digitalmente l’eseguibile. Per farlo abbiamo bisogno del comando signtool disponibile in Windows SDK.

Affinché signtool funzioni è necessario aggiungerlo al PATH di sistema, per farlo apriamo il Pannello di controllo > Sistema > Impostazioni avanzate > Variabili di ambiente e aggiungiamo a PATH il percorso di installazione corretto C:\Program Files (x86)\Windows Kits\10\App Certification Kit

Questo percorso potrebbe cambiare in base all’installazione del SDK fatta in precedenza.

Una volta che tutto è pronto spostiamoci nella cartella dove abbiamo il nostro eseguibile compilato ed eseguiamo:

signtool sign /a /t http://timestamp.digicert.com /fd SHA256 /v .\WordUnlocker.exe

1	signtool sign /a /t http://timestamp.digicert.com /fd SHA256 /v .\WordUnlocker.exe

Fatto tutto questo avremo il nostro file correttamente firmato. E’ possibile scaricare il file eseguibile dal link seguente:

WordUnlocker

[python] Semplice programma di crittografia dei file con password

Il nostro obiettivo di oggi è criptare un file proteggendolo con una password in Python.

Anzitutto abbiamo bisogno della libreria cryptography. Per installarla utilizziamo come al solito PIP:

pip install cryptography

Per i neofiti basta aprire il Terminale su Windows (WIN+R e digitare cmd) ed eseguire il comando.

Quello che andremo a realizzare sarà un semplice programma da Terminale, dove ci siano due opzioni, una per criptare e una per decriptare il file. Il programma dovrà comportarsi più o meno in questo modo:

Anzitutto cominciamo col creare la base del nostro programma, che si svolgerà tutto in un ciclo while infinito. Dobbiamo prevedere 3 opzioni: crittare il file, decrittare il file e un’opzione per uscire/terminare il programma (questa è la prima opzione che implementeremo, per evitare di restare bloccati nell’esecuzione infinita):

while True:

    print("-- programma di crittografia dei file --")
    print("1. critta file")
    print("2. decritta file")
    print("0. esci")

    try:
        scelta = int(input("scelta: "))
    except:
        print("ERRORE! Scelta non valida!")
        scelta = -1

    if scelta == 0: break

while True:

print("-- programma di crittografia dei file --")

print("1. critta file")

print("2. decritta file")

print("0. esci")

try:

scelta = int(input("scelta: "))

except:

print("ERRORE! Scelta non valida!")

scelta = -1

if scelta == 0: break

Dalla libreria cryptography importeremo Fernet per la crittografia simmetrica, le caratteristiche salienti del sistema Fernet sono:

Crittografia simmetrica: Utilizzo della medesima chiave per cifrare e decifrare i dati
Sicurezza: gli algoritmi di cifratura utilizzati sono del tipo AES in modalità CBC con una chiave da 128 bit
Autenticazione dei dati: include HMAC per garantire, laddove necessario, l’integrità e l’autenticità dei dati cifrati

La più blanda implementazione di questo algoritmo potrebbe essere fatta nel modo seguente:

from cryptography.fernet import Fernet

# generiamo una chiave
chiave = Fernet.generate_key()

# inizializziamo Fernet con la chiave generata
fernet = Fernet(chiave)

# testo da cifrare
messaggio = "Presto sarà primavera. E i frutteti saranno in fiore. E gli uccelli nidieranno nel boschetto di nocciole. E l'orzo estivo sarà seminato nei campi a valle. E si mangeranno le prime fragole con la panna. Vi ricordate il sapore delle fragole?"

# cifriamo il messaggio
messaggio_cifrato = fernet.encrypt(messaggio.encode())

# stampiamo il messaggio cifrato
print(f"Messaggio cifrato: {messaggio_cifrato.decode()}")

from cryptography.fernet import Fernet

# generiamo una chiave

chiave = Fernet.generate_key()

# inizializziamo Fernet con la chiave generata

fernet = Fernet(chiave)

# testo da cifrare

messaggio = "Presto sarà primavera. E i frutteti saranno in fiore. E gli uccelli nidieranno nel boschetto di nocciole. E l'orzo estivo sarà seminato nei campi a valle. E si mangeranno le prime fragole con la panna. Vi ricordate il sapore delle fragole?"

# cifriamo il messaggio

messaggio_cifrato = fernet.encrypt(messaggio.encode())

# stampiamo il messaggio cifrato

print(f"Messaggio cifrato: {messaggio_cifrato.decode()}")

Il risultato sarà qualcosa del genere:

In questo caso, faccio notare, abbiamo usato una chiave generata direttamente dal programma, mentre quello che vogliamo fare in questo esercizio è usare una password come chiave di crittografia.

A tale scopo implementiamo una funzione di creazione della chiave a partire da una password data dall’utente:

import base64, hashlib

def crea_password(pswd):
    hlib = hashlib.md5()
    hlib.update(pswd.encode("utf-8"))
    return base64.urlsafe_b64encode(hlib.hexdigest().encode('utf8'))

import base64, hashlib

def crea_password(pswd):

hlib = hashlib.md5()

hlib.update(pswd.encode("utf-8"))

return base64.urlsafe_b64encode(hlib.hexdigest().encode('utf8'))

A questo punto possiamo passare all’implementazione del resto del programma.

Anzitutto gestiamo la scelta 1, dove chiederemo all’utente di darci il percorso del file e una password da usare per la crittazione.

    if scelta == 1:
        file = input("file: ")
        pswd = getpass.getpass("password: ")

        if os.path.isfile(file):
            with open(file,"rb") as fp:
                dati = fp.read()
            chiave = crea_password(pswd)
            fernet = Fernet(chiave)
            dati_crittati = fernet.encrypt(dati)
            with open(file,"wb") as fp:
                fp.write(dati_crittati)
            print("File criptato con successo!")
        else:
            print("ERRORE! Impossibile trovare il file")

if scelta == 1:

file = input("file: ")

pswd = getpass.getpass("password: ")

if os.path.isfile(file):

with open(file,"rb") as fp:

dati = fp.read()

chiave = crea_password(pswd)

fernet = Fernet(chiave)

dati_crittati = fernet.encrypt(dati)

with open(file,"wb") as fp:

fp.write(dati_crittati)

print("File criptato con successo!")

else:

print("ERRORE! Impossibile trovare il file")

Faccio notare come in questa parte richiediamo in input un percorso per il file e usiamo getpass per acquisire la password (funzionerà sul Terminale, mentre sull’IDLE Shell la password sarà esposta in chiaro!).

Una volta acquisito il nome/percorso del file, verifichiamo se effettivamente esiste, in tal caso lo apriamo in lettura con l’opzione rb (per leggere in modo binario), creiamo la chiave a partire dalla password e cifriamo il file.

Per la decrittazione l’operazione sarà analoga, ma alla rovescia:

    if scelta == 2:
        file = input("file: ")
        pswd = getpass.getpass("password: ")

        if os.path.isfile(file):
            with open(file,"rb") as fp:
                dati = fp.read()
            chiave = crea_password(pswd)
            fernet = Fernet(chiave)
            dati_decrittati = fernet.decrypt(dati)
            with open(file,"wb") as fp:
                fp.write(dati_decrittati)
            print("File decriptato con successo!")
        else:
            print("ERRORE! Impossibile trovare il file")

if scelta == 2:

file = input("file: ")

pswd = getpass.getpass("password: ")

if os.path.isfile(file):

with open(file,"rb") as fp:

dati = fp.read()

chiave = crea_password(pswd)

fernet = Fernet(chiave)

dati_decrittati = fernet.decrypt(dati)

with open(file,"wb") as fp:

fp.write(dati_decrittati)

print("File decriptato con successo!")

else:

print("ERRORE! Impossibile trovare il file")

Il codice complessivo sarà così:

from cryptography.fernet import Fernet
import base64, hashlib
import getpass
import os

def crea_password(pswd):
    hlib = hashlib.md5()
    hlib.update(pswd.encode("utf-8"))
    return base64.urlsafe_b64encode(hlib.hexdigest().encode('utf8'))

while True:

    print("-- programma di crittografia dei file --")
    print("1. critta file")
    print("2. decritta file")
    print("0. esci")

    try:
        scelta = int(input("scelta: "))
    except:
        print("ERRORE! Scelta non valida!")
        scelta = -1

    if scelta == 0: break

    if scelta == 1:
        file = input("file: ")
        pswd = getpass.getpass("password: ")

        if os.path.isfile(file):
            with open(file,"rb") as fp:
                dati = fp.read()
            chiave = crea_password(pswd)
            fernet = Fernet(chiave)
            dati_crittati = fernet.encrypt(dati)
            with open(file,"wb") as fp:
                fp.write(dati_crittati)
            print("File criptato con successo!")
        else:
            print("ERRORE! Impossibile trovare il file")

    if scelta == 2:
        file = input("file: ")
        pswd = getpass.getpass("password: ")

        if os.path.isfile(file):
            with open(file,"rb") as fp:
                dati = fp.read()
            chiave = crea_password(pswd)
            fernet = Fernet(chiave)
            dati_decrittati = fernet.decrypt(dati)
            with open(file,"wb") as fp:
                fp.write(dati_decrittati)
            print("File decriptato con successo!")
        else:
            print("ERRORE! Impossibile trovare il file")

from cryptography.fernet import Fernet

import base64, hashlib

import getpass

import os

def crea_password(pswd):

hlib = hashlib.md5()

hlib.update(pswd.encode("utf-8"))

return base64.urlsafe_b64encode(hlib.hexdigest().encode('utf8'))

while True:

print("-- programma di crittografia dei file --")

print("1. critta file")

print("2. decritta file")

print("0. esci")

try:

scelta = int(input("scelta: "))

except:

print("ERRORE! Scelta non valida!")

scelta = -1

if scelta == 0: break

if scelta == 1:

file = input("file: ")

pswd = getpass.getpass("password: ")

if os.path.isfile(file):

with open(file,"rb") as fp:

dati = fp.read()

chiave = crea_password(pswd)

fernet = Fernet(chiave)

dati_crittati = fernet.encrypt(dati)

with open(file,"wb") as fp:

fp.write(dati_crittati)

print("File criptato con successo!")

else:

print("ERRORE! Impossibile trovare il file")

if scelta == 2:

file = input("file: ")

pswd = getpass.getpass("password: ")

if os.path.isfile(file):

with open(file,"rb") as fp:

dati = fp.read()

chiave = crea_password(pswd)

fernet = Fernet(chiave)

dati_decrittati = fernet.decrypt(dati)

with open(file,"wb") as fp:

fp.write(dati_decrittati)

print("File decriptato con successo!")

else:

print("ERRORE! Impossibile trovare il file")

[risolto] In WordPress non viene mostrato il contenuto della pagina del template selezionata, bensì il contenuto di index.php

Problema: In WordPress, selezionando un template per una pagina, non viene mostrato il contenuto del template, bensì il contenuto della pagina index.php del tema stesso

Soluzione: Nel backend di WordPress andare su Impostazioni > Permalink e premere sul tasto Salva modifiche. Questo dovrebbe risolvere il problema.

[risolto] Windows 11 24H2 crasha durante l’avvio bloccandosi in loop tra tentativi di ripristino e sblocco BitLocker

Problema: Windows 11 24H2 si blocca all’avvio, finendo in loop tra tentativi di ripristino e sblocco di BitLocker. Nessuna opzione di ripristino sembra sortire alcun effetto, né la riparazione dei settori di BOOT né altre funzioni annesse, ivi compreso il controllo del disco (inutili chkdsk, bootrec, ecc). Se si riavvia in Safe Mode with Networking (F5) il sistema ugualmente non parte.

Soluzione: Entrare nella modalità di ripristino, selezionare Opzioni Avanzate e poi Impostazioni di avvio, qui selezionare Disable driver signature enforcement (F7) e riavviare, dopodiché ricercare i driver che creano conflitti

La prima volta che mi si è presentato questo problema abbastanza assurdo e fastidioso è stato il 17 luglio 2024, dopo l’aggiornamento a Windows 11 Pro 24H2.

Fino a quel momento il computer aveva funzionato correttamente sempre con Windows 11 installato sopra. Poi non era più possibile avviarlo.

Il problema principale è che non vi è una segnalazione chiara che consenta all’utente di individuare questo errore. Windows 11 semplicemente non parte più.

Tant’è che lì per lì mi sono trovato a formattarlo e, nell’impossibilità di continuare ad usarlo dopo un secondo crash, a reinstallare Windows 10.

Il sistema è rimasto stabile fino a metà novembre 2024, quando ho deciso di tornare a Windows 11, anche perché gli aggiornamenti per Windows 10 stavano per essere interrotti.

Il problema si presentava con i seguenti sintomi:

Impossibile del tutto avviare Windows 11, il computer si riavvia dopo pochi secondi in una serie di sussulti, finché non parte il tentativo di ripristino
Richiesta continua di sblocco del BitLocker per accedere al disco
Nessuna funzione di ripristino funziona, come per esempio Disinstalla ultimo aggiornamento oppure Ripristina avvio del PC (anzi, questa in un’occasione ha portato ad una formattazione automatica, assolutamente non richiesta, di Windows stesso)
sfc /scannow non produce alcun effetto (il commando più corretto sarebbe sfc /scannow /offbootdir=C:\ /offwindir=C:\Windows)
chkdsk non produce alcun errore o effetto
aggiungere su HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\StorPort oppure su HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\stornvme\Parameters\Device DWORD HmbAllocationPolicy impostato su 0 o 2 (0 = HMB allocation off, 2 = HMB allocation 64MB) non cambia nulla (problema riscontrato su alcuni dischi WD, tipo SN770 e SN580)
nel file SrtTrail.txt non ci sono errori, eccetto un’informazione fuorviante circa “un file binario di avvio ripristinato di recente è danneggiato” con un suggerimento anche peggiore “Operazione correttiva: Disinstalla LCU più recente“:
Avviando in Safe Mode with Networking (F5) il sistema non parte (primo indizio)
Avviando in Safe Mode (F4) il sistema parte, ma non è possibile accedere (vi dice Configura il tuo PIN, ma non essendoci la rete l’operazione è impossibile e il computer si blocca in un loop infinito) (secondo indizio!)

Arrivato a questo punto ho cominciato ad intuire che doveva trattarsi di qualcosa che aveva a che fare con la rete o con dei driver associati.

A questo punto ho provato a riavviare con l’opzione Disable driver signature enforcement (F7) e il computer è miracolosamente partito.

La procedura completa consiste nell’avviare la schermata di ripristino di Windows 11 (in teoria premendo F11 subito all’avvio, benché in alcuni computer possa essere F9 o F10)

Selezionare Risoluzione dei problemi.

In questa schermata selezionare Impostazioni di avvio.

Selezionare Opzioni avanzate.

Selezionare Riavvia (in questa schermata non si può fare altro).

Nel caso in cui è attivo il BitLocker (su Windows 11 Pro) comparirà questa schermata, premiamo INVIO e dobbiamo inserire il codice a 48 cifre associato al BitLocker (è possibile trovarlo a questo link effettuando il login con l’account Microsoft associato al computer: https://aka.ms/myrecoverykey). In caso contrario si passa direttamente a questa schermata.

A questo punto premere F7 Disabilita imposizione firma driver (Disable driver signature enforcement).

Il computer si riavvierà e dovrebbe essere tutto in regola.

Il problema principale è che questa operazione va eseguita ad ogni riavvio (anche quando viene effettuato dagli aggiornamenti di sistema).

Per evitare di dover ogni volta, ad ogni riavvio, rieseguire tutta questa trafila, è possibile mettersi alla ricerca dei driver che creano problemi.

Aprire Impostazioni > Privacy e sicurezza > Sicurezza di Windows.

Cliccare su Apri Sicurezza di Windows.

Andare su Sicurezza dispositivi.

All’opzione Isolamento core effettuare una Nuova analisi e poi andare su Verifica driver non compatibili. Qui dovrebbero comparire i driver che creano problemi.

In questo caso c’è un driver PxHlpa64.sys non compatibile.

Questo è un driver installato tipicamente da terze parti, rivolto alla gestione di software di masterizzazione dei dischi. Nel mio caso, non avendo nemmeno un lettore CD/DVD posso rimuoverlo liberamente. Per farlo individuare il file in C:\Windows\System32\drivers

Rimuovere il file, dopodiché individuare la sua posizione nel registro di sistema. Premere WIN + R, digitare regedit e premere ancora INVIO.

Cercare nel registro la voce in HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\

Rimuovere la voce dal registro.

Inutile dire quanto sarebbe gradito, da parte di Microsoft, rendere più esplicito questo errore e soprattutto prevedere di prevenirlo (se ho installato un driver non firmato, bloccami semmai durante l’installazione, ma una volta che ho deciso di procedere non puoi bloccarmi tutto il sistema operativo dopo un qualsiasi riavvio).

[JavaScript] Calcola il percorso più breve tra due punti su una griglia

Vediamo oggi come creare in JavaScript una griglia sulla quale posizionare due punti e trovare il percorso più breve evitando degli ostacoli.

A titolo di curiosità ho svolto un esercizio simile (ma senza l’uso di Nodi) in Python: [python] Esercizio su funzioni ricorsive e calcolo del percorso minore possibile

Il risultato che vogliamo ottenere sarà simile a questo (avere la possibilità di impostare una dimensione e il numero di ostacoli). Versione semplice:

Versione un po’ più complicata:

Questo esercizio è consultabile anche al seguente link.

Procediamo con ordine e andiamo anzitutto a creare una classe per gestire le singole celle e quelle ad esse collegate. Vogliamo creare un sistema collegato a nodi, che rappresenti la connessione tra tutte le celle. Definiamo perciò una classe nel modo seguente:

const CellaTipo = {
	Vuota: 0,
	Ostacolo: 1,
	Partenza: 2,
	Fine: 3,
	Percorso: 4
}

class Cella {
	constructor(tipo = CellaTipo.Vuota) {
		this.tipo = tipo;
		this.vicini = [];
		this.coor = {r:null,c:null};
	}
	addVicino(nodo) {
		if(!this.vicini.includes(nodo)) 
			this.vicini.push(nodo);
		if(!nodo.vicini.includes(this)) 
			nodo.vicini.push(this);
	}
	setCoor(r,c) {
		this.coor.r = r;
		this.coor.c = c;
		return this;
	}
}

const CellaTipo = {

Vuota: 0,

Ostacolo: 1,

Partenza: 2,

Fine: 3,

Percorso: 4

}

class Cella {

constructor(tipo = CellaTipo.Vuota) {

this.tipo = tipo;

this.vicini = [];

this.coor = {r:null,c:null};

}

addVicino(nodo) {

if(!this.vicini.includes(nodo))

this.vicini.push(nodo);

if(!nodo.vicini.includes(this))

nodo.vicini.push(this);

}

setCoor(r,c) {

this.coor.r = r;

this.coor.c = c;

return this;

}

In particolare voglio mettere in evidenza il metodo addVicino(nodo)

	addVicino(nodo) {
		if(!this.vicini.includes(nodo)) 
			this.vicini.push(nodo);
		if(!nodo.vicini.includes(this)) 
			nodo.vicini.push(this);
	}

addVicino(nodo) {

if(!this.vicini.includes(nodo))

this.vicini.push(nodo);

if(!nodo.vicini.includes(this))

nodo.vicini.push(this);

}

Vogliamo che ogni nodo sia interconnesso con il proprio vicino, quindi se abbiamo due nodi A e B allora A avrà nei vicini B e B avrà nei vicini A.

Costruiamo adesso la classe che creerà la mappa. Nel codice ho inserito i commenti ai vari metodi:

class Mappa {
	
	/*
	COSTRUTTORE: Di predefinito partiamo con 10 x 10 come dimensione della mappa e con un numero di ostacoli da definire (poi metteremo anche quello a 10)
	*/
	constructor(n = 10,ostacoli) {
		
		this.nodi = [];
		this.n = n;
		this.inizio = null;
		this.fine = null;
		
		this.setOstacoli(ostacoli);
		this.costruisciMappa();
		this.costruisciOstacoli();
		
	}
	
	/*
	COSTRUIAMO LA MAPPA: Noi sappiamo che la mappa è una griglia quadrata limitata, dove gli spostamenti possibili sono solo in verticale e orizzontale, non è possibile spostarsi in diagonale.
	NB: I nodi li mettiamo in una lista di nodi unidimensionale, rispetto alla mappa bidimensionale
	*/
	costruisciMappa() {
		
		this.nodi = [];
		
		for(var r = 0; r < this.n; r++ ) {
			for(var c = 0; c < this.n; c++ ) {
				// qui convertiamo le coordinate in una sola dimensione
				var posCorr = r * this.n + c;
				// aggiungiamo il nodo
				this.nodi.push((new Cella()).setCoor(r,c));
				if( c > 0 ) {
					// colleghiamo subito il nodo con quelli appena precedenti
					this.nodi[posCorr].addVicino(this.nodi[posCorr-1]);
				}
				if( r > 0 ) {
					// colleghiamo subito il nodo con quelli soprastanti
					this.nodi[posCorr].addVicino(this.nodi[posCorr-this.n]);
				}
			}
		}
		
	}
	
	// impostiamo il numero di ostacoli
	setOstacoli(ostacoli) {
		this.ostacoli = ostacoli;
	}
	
	// creiamo gli ostacoli con una funzione casuale
	costruisciOstacoli() {
		
		var o = 0;
		while(o < this.ostacoli) {
			// troviamo una posizione casuale all'interno della lista dei nodi
			var pos = Math.round((this.n*this.n-1)*Math.random());
			// nel caso in cui la cella sia vuota
			if( this.nodi[pos].tipo == CellaTipo.Vuota ) {
				// impostiamo l'ostacolo
				this.nodi[pos].tipo = CellaTipo.Ostacolo;
				o++;
			}
		}
		
	}
	
	hasPartenza() {
		return this.inizio != null;
	}
	
	hasFine() {
		return this.fine != null;
	}
	
	getNodo(r,c) {
		var pos = r * this.n + c;
		return this.nodi[pos];
	}
	
	// impostiamo la partenza
	setPartenza(r,c) {
		if( this.inizio != null ) return false;
		var pos = r * this.n + c;
		if( this.nodi[pos].tipo == CellaTipo.Vuota ) {
			this.nodi[pos].tipo = CellaTipo.Partenza;
			this.inizio = pos;
			return true;
		}
		return false;
	}
	
	// impostiamo la fine
	setFine(r,c) {
		if( this.fine != null ) return false;
		var pos = r * this.n + c;
		if( this.nodi[pos].tipo == CellaTipo.Vuota ) {
			this.nodi[pos].tipo = CellaTipo.Fine;
			this.fine = pos;
			return true;
		}
		return false;
	}
	
	// calcoliamo il percorso, facendo anche un po' di statistiche 
	calcolaPercorso() {
		if( this.inizio != null && this.fine != null ) {
		
			this.percorsi = [];
			this.shortest = [];
			this.maxlen = null;
			
			this.scartati_lung = 0;
			this.scartati_vici = 0;
			this.tstart = new Date();
			
			this.calcolo(this.nodi[this.inizio],[]);
			
			this.tend = new Date();
			
			console.log("Tempo di calcolo: "+Math.round((this.tend-this.tstart))+"ms, Scartati troppo lunghi: "+this.scartati_lung+", Scartati per vicini: "+this.scartati_vici);
		
		}
		return null;
	}
	
	// controlliamo che il percorso non curvi inutilmente, in base al numero di vicini prossimi ad ogni nodo
	nMaxVicini(nodo,percorso) {
		
		var vicini = 0;
		for(var i = 0; i < percorso.length; i++ ) {
			if(nodo.vicini.includes(percorso[i])) vicini++;
		}
		return vicini;
		
	}
	
	/*
	CALCOLO: qui calcoliamo il percorso a partire da un nodo dato in poi, spostandoci su ogni vicino del nodo, finché non troviamo il nodo finale
	*/
	calcolo(nodo,percorso) {
		
		// se la lunghezza del percorso attuale supera il percorso dalla lunghezza minima trovato, allora interrompiamo la funzione ricorsiva
		if( this.maxlen != null && percorso.length >= this.maxlen ) 
		{
			this.scartati_lung++;
			return;
		}
		
		// se il nodo non è già contenuto nel percorso, aggiungiamolo
		if( !percorso.includes(nodo) ) {
			
			// se il numero di vicini è maggiore di 2 interrompiamo il calcolo
			if( this.nMaxVicini(nodo,percorso) > 2 ) {
				this.scartati_vici++;
				return;
			}
			
			percorso.push(nodo);
			// proseguiamo su ogni vicino del nodo
			for(var i = 0; i < nodo.vicini.length; i++ ) {
				if( nodo.vicini[i].tipo == CellaTipo.Fine ) {
					// abbiamo trovato un percorso
					percorso.push(nodo.vicini[i]);
					var len = percorso.length;
					if( len < this.maxlen || this.maxlen == null ) {
						this.maxlen = len;
						this.shortest = percorso.slice();
					}
					this.percorsi.push(percorso.slice());
				}
				if( nodo.vicini[i].tipo == CellaTipo.Vuota ) {
					this.calcolo(nodo.vicini[i],percorso.slice());
				}
			}
		}
		
	}
	
}

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

class Mappa {

COSTRUTTORE: Di predefinito partiamo con 10 x 10 come dimensione della mappa e con un numero di ostacoli da definire (poi metteremo anche quello a 10)

constructor(n = 10,ostacoli) {

this.nodi = [];

this.n = n;

this.inizio = null;

this.fine = null;

this.setOstacoli(ostacoli);

this.costruisciMappa();

this.costruisciOstacoli();

}

COSTRUIAMO LA MAPPA: Noi sappiamo che la mappa è una griglia quadrata limitata, dove gli spostamenti possibili sono solo in verticale e orizzontale, non è possibile spostarsi in diagonale.

NB: I nodi li mettiamo in una lista di nodi unidimensionale, rispetto alla mappa bidimensionale

costruisciMappa() {

this.nodi = [];

for(var r = 0; r < this.n; r++ ) {

for(var c = 0; c < this.n; c++ ) {

// qui convertiamo le coordinate in una sola dimensione

var posCorr = r * this.n + c;

// aggiungiamo il nodo

this.nodi.push((new Cella()).setCoor(r,c));

if( c > 0 ) {

// colleghiamo subito il nodo con quelli appena precedenti

this.nodi[posCorr].addVicino(this.nodi[posCorr-1]);

}

if( r > 0 ) {

// colleghiamo subito il nodo con quelli soprastanti

this.nodi[posCorr].addVicino(this.nodi[posCorr-this.n]);

}

// impostiamo il numero di ostacoli

setOstacoli(ostacoli) {

this.ostacoli = ostacoli;

}

// creiamo gli ostacoli con una funzione casuale

costruisciOstacoli() {

var o = 0;

while(o < this.ostacoli) {

// troviamo una posizione casuale all'interno della lista dei nodi

var pos = Math.round((this.n*this.n-1)*Math.random());

// nel caso in cui la cella sia vuota

if( this.nodi[pos].tipo == CellaTipo.Vuota ) {

// impostiamo l'ostacolo

this.nodi[pos].tipo = CellaTipo.Ostacolo;

o++;

}

hasPartenza() {

return this.inizio != null;

}

hasFine() {

return this.fine != null;

}

getNodo(r,c) {

var pos = r * this.n + c;

return this.nodi[pos];

}

// impostiamo la partenza

setPartenza(r,c) {

if( this.inizio != null ) return false;

var pos = r * this.n + c;

if( this.nodi[pos].tipo == CellaTipo.Vuota ) {

this.nodi[pos].tipo = CellaTipo.Partenza;

this.inizio = pos;

return true;

}

return false;

}

// impostiamo la fine

setFine(r,c) {

if( this.fine != null ) return false;

var pos = r * this.n + c;

if( this.nodi[pos].tipo == CellaTipo.Vuota ) {

this.nodi[pos].tipo = CellaTipo.Fine;

this.fine = pos;

return true;

}

return false;

}

// calcoliamo il percorso, facendo anche un po' di statistiche

calcolaPercorso() {

if( this.inizio != null && this.fine != null ) {

this.percorsi = [];

this.shortest = [];

this.maxlen = null;

this.scartati_lung = 0;

this.scartati_vici = 0;

this.tstart = new Date();

this.calcolo(this.nodi[this.inizio],[]);

this.tend = new Date();

console.log("Tempo di calcolo: "+Math.round((this.tend-this.tstart))+"ms, Scartati troppo lunghi: "+this.scartati_lung+", Scartati per vicini: "+this.scartati_vici);

}

return null;

}

// controlliamo che il percorso non curvi inutilmente, in base al numero di vicini prossimi ad ogni nodo

nMaxVicini(nodo,percorso) {

var vicini = 0;

for(var i = 0; i < percorso.length; i++ ) {

if(nodo.vicini.includes(percorso[i])) vicini++;

}

return vicini;

}

CALCOLO: qui calcoliamo il percorso a partire da un nodo dato in poi, spostandoci su ogni vicino del nodo, finché non troviamo il nodo finale

calcolo(nodo,percorso) {

// se la lunghezza del percorso attuale supera il percorso dalla lunghezza minima trovato, allora interrompiamo la funzione ricorsiva

if( this.maxlen != null && percorso.length >= this.maxlen )

{

this.scartati_lung++;

return;

}

// se il nodo non è già contenuto nel percorso, aggiungiamolo

if( !percorso.includes(nodo) ) {

// se il numero di vicini è maggiore di 2 interrompiamo il calcolo

if( this.nMaxVicini(nodo,percorso) > 2 ) {

this.scartati_vici++;

return;

}

percorso.push(nodo);

// proseguiamo su ogni vicino del nodo

for(var i = 0; i < nodo.vicini.length; i++ ) {

if( nodo.vicini[i].tipo == CellaTipo.Fine ) {

// abbiamo trovato un percorso

percorso.push(nodo.vicini[i]);

var len = percorso.length;

if( len < this.maxlen || this.maxlen == null ) {

this.maxlen = len;

this.shortest = percorso.slice();

}

this.percorsi.push(percorso.slice());

}

if( nodo.vicini[i].tipo == CellaTipo.Vuota ) {

this.calcolo(nodo.vicini[i],percorso.slice());

}

In particolare vorrei soffermarmi sul controllo dei vicini con il metodo nMaxVicini(nodo,percorso)

Durante la ricerca del percorso voglio evitare tutti quei percorsi che si annodano a serpentina, perché tanto non sarebbero mai il percorso migliore. Se un percorso è così annodato, significa che esiste un nodo che ha almeno 3 vicini, durante la costruzione almeno 2 (ricordiamoci che il nodo successivo non è stato ancora aggiunto). Quindi ogni nodo, durante la costruzione, non deve avere più di un vicino.

Completiamo il tutto con la creazione della griglia vera e propria:

var mappa = null;

function avvioMappa(d, o) {
	
	mappa = new Mappa(d, o);
	
	$('#griglia').html("");
	$('#griglia').css("width",(d*52)+"px");
	$('#griglia').css("height",(d*52)+"px");
	
	for(var r = 0; r < d; r++ ) {
		for(var c = 0; c < d; c++ ) {
			var cont = mappa.getNodo(r,c).tipo == CellaTipo.Ostacolo ? "X" : "&nbsp;";
			$('#griglia').append('<div class="cella'+(cont=="X"?" ostacolo":"")+'" data-row="'+r+'" data-col="'+c+'">'+cont+'</div>');
		}
	}
	
	$('.cella').unbind();
	$('.cella').click(function() {
		var r = parseInt($(this).attr("data-row"));
		var c = parseInt($(this).attr("data-col"));
		if( !mappa.hasPartenza() ) {
			if( !mappa.setPartenza(r,c) ) alert("casella non valida");
			else $(this).html("A").css("color","red");
		} else {
			if( !mappa.setFine(r,c) ) alert("casella non valida");
			else $(this).html("B").css("color","green");
		}
	});
	
	$('#trova').unbind();
	$('#trova').click(function(){
		
		if( mappa.hasFine() ) {
			
			mappa.calcolaPercorso();
			
			if( mappa.shortest.length > 0 ) {
				
				for(var i = 0; i < mappa.shortest.length; i++ ) {
					var r = mappa.shortest[i].coor.r;
					var c = mappa.shortest[i].coor.c;
					if( mappa.shortest[i].tipo == CellaTipo.Vuota )
						$('.cella[data-row='+r+'][data-col='+c+']').html("&bull;").css("color","blue");
				}
				
			} else {
				alert("Impossibile trovare percorso!");
			}
			
		} else {
			alert("Imposta percorso!");
		}
		
	});
	
}

$(document).ready(function(){
		
	$('#mostra').click(function(){
		
		var dim = parseInt($('#dimensione').val());
		var ost = parseInt($('#ostacoli').val());
		
		if( dim > 1 && ost >= 0 && ost <= dim * dim ) {
		
			avvioMappa(dim, ost);
		
		} else {
			
			alert("Valori non validi!");
			
		}
		
	});
	
});

var mappa = null;

function avvioMappa(d, o) {

mappa = new Mappa(d, o);

$('#griglia').html("");

$('#griglia').css("width",(d*52)+"px");

$('#griglia').css("height",(d*52)+"px");

for(var r = 0; r < d; r++ ) {

for(var c = 0; c < d; c++ ) {

var cont = mappa.getNodo(r,c).tipo == CellaTipo.Ostacolo ? "X" : " ";

$('#griglia').append('<div class="cella'+(cont=="X"?" ostacolo":"")+'" data-row="'+r+'" data-col="'+c+'">'+cont+'</div>');

}

$('.cella').unbind();

$('.cella').click(function() {

var r = parseInt($(this).attr("data-row"));

var c = parseInt($(this).attr("data-col"));

if( !mappa.hasPartenza() ) {

if( !mappa.setPartenza(r,c) ) alert("casella non valida");

else $(this).html("A").css("color","red");

} else {

if( !mappa.setFine(r,c) ) alert("casella non valida");

else $(this).html("B").css("color","green");

}

});

$('#trova').unbind();

$('#trova').click(function(){

if( mappa.hasFine() ) {

mappa.calcolaPercorso();

if( mappa.shortest.length > 0 ) {

for(var i = 0; i < mappa.shortest.length; i++ ) {

var r = mappa.shortest[i].coor.r;

var c = mappa.shortest[i].coor.c;

if( mappa.shortest[i].tipo == CellaTipo.Vuota )

$('.cella[data-row='+r+'][data-col='+c+']').html("•").css("color","blue");

}

} else {

alert("Impossibile trovare percorso!");

}

} else {

alert("Imposta percorso!");

}

});

}

$(document).ready(function(){

$('#mostra').click(function(){

var dim = parseInt($('#dimensione').val());

var ost = parseInt($('#ostacoli').val());

if( dim > 1 && ost >= 0 && ost <= dim * dim ) {

avvioMappa(dim, ost);

} else {

alert("Valori non validi!");

}

});

E naturalmente con un po’ di CSS:

#griglia {
	width: 520px;
	height: 520px;
	display: flex;
	flex-wrap: wrap;
	margin-top: 12px;
}
.cella {
	width: 50px;
	height: 50px;
	line-height: 50px;
	border: 1px solid #333;
	text-align: center;
	font-family: Verdana;
	font-size: 32px;
	cursor: pointer;
}
.ostacolo {
	background-color: #f00;
}

#griglia {

width: 520px;

height: 520px;

display: flex;

flex-wrap: wrap;

margin-top: 12px;

}

.cella {

width: 50px;

height: 50px;

line-height: 50px;

border: 1px solid #333;

text-align: center;

font-family: Verdana;

font-size: 32px;

cursor: pointer;

}

.ostacolo {

background-color: #f00;

}

E infine la pagina HTML per mettere il tutto insieme.

<html>

	<head>
		<title>Calcolo del percorso</title>
		<link href="percorso.css" rel="stylesheet">
	</head>
	
	<body>
	
		<input type="text" id="dimensione" value="10" placeholder="dimensione">
		<input type="text" id="ostacoli" value="10" placeholder="n. ostacoli">
		<button type="button" id="mostra">Mostra griglia</button>
		<button type="button" id="trova">Trova percorso</button>
	
		<div id="griglia"></div>
	
	</body>
	
	<script src="jquery-3.6.1.min.js"></script>
	<script src="percorso.js"></script>
	<script src="main.js"></script>


</html>

<html>

<head>

<title>Calcolo del percorso</title>

</head>

<body>

<button type="button" id="mostra">Mostra griglia</button>

<button type="button" id="trova">Trova percorso</button>

</body>

</html>

Vediamo infine un esempio funzionante del codice.

[JavaScript] Esercizio per realizzare il gioco del campo minato

Vediamo come realizzare un prototipo del gioco del campo minato, ideato da Robert Donner e Curt Johnson e pubblicato nel 1990 nella raccolta Microsoft Entertainment Pack 1 per Windows 3.1. Negli anni successivi il gioco divenne famoso anche con il nome Prato Fiorito.

Il gioco si basa sullo scoprire le mine nascoste nel campo, quando si scopre una cella che non contiene mine questa può essere vuota, oppure avere un numero che ci indica quante mine limitrofe sono presenti. Il risultato che vogliamo ottenere sarà simile a questo:

Per questo esercizio ho utilizzato il font Digital Counter 7, sviluppato da Sizenko Alexander

Anzitutto abbiamo bisogno di creare lo spazio per il nostro gioco. Creiamo quindi una pagina HTML come nel codice seguente:

<html>
	
	<head>
		<title>Campo Minato</title>
		<link rel="preconnect" href="https://fonts.googleapis.com">
		<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
		<link href="https://fonts.googleapis.com/css2?family=Roboto:wght@100;300;400;700&display=swap" rel="stylesheet">
		<link href="css/font-awesome.min.css" rel="stylesheet">
		<link href="campominato.css" rel="stylesheet">
	</head>
	
	<body>
	
		<div id="griglia"></div>
		
		<div id="stato"></div>
	
	</body>
	
	<script src="jquery-3.6.1.min.js"></script>
	<script src="campominato.js"></script>


</html>

<html>

<head>

<title>Campo Minato</title>

</head>

<body>

</body>

</html>

Ogni cella del gioco dovrà contenere 4 proprietà diverse:

indicatore se c’è o meno una mina
indicatore se la cella sia o meno aperta
il conteggio delle mine limitrofe
indicatore se è stata messa o meno una bandierina

Faccio notare come i punti 3 e 1 possono essere riassunti in un’unica variabile, all’occorenza.

Creiamo quindi anzitutto un oggetto opportuno nel modo seguente:

class Cella {
	constructor(mina) {
		this.mina = mina;
		this.aperta = false;
		this.cont = 0;
		this.flag = false;
	}
}

class Cella {

constructor(mina) {

this.mina = mina;

this.aperta = false;

this.cont = 0;

this.flag = false;

}

Dentro a $(document).ready(function() {}); andiamo ad inizializzare il resto del gioco come segue.

Anzitutto popoliamo il nostro campo di celle:

for(r = 0; r < n; r++) {
	campo[r] = [];
	for(c = 0; c < n; c++) {
		campo[r][c] = new Cella(false);
		$('#griglia').append('<div class="cella" data-row="'+r+'" data-col="'+c+'">&nbsp;</div>');
	}
	//$('#griglia').append("<br>");
}

for(r = 0; r < n; r++) {

campo[r] = [];

for(c = 0; c < n; c++) {

campo[r][c] = new Cella(false);

$('#griglia').append('<div class="cella" data-row="'+r+'" data-col="'+c+'"> </div>');

}

//$('#griglia').append("<br>");

}

Andiamo poi a distribuire tutte le mine, in base al numero prescelto.

m = 0;
while(m < mine) {
	pr = Math.round((n-1)*Math.random());
	pc = Math.round((n-1)*Math.random());
	if( !campo[pr][pc].mina ) {
		campo[pr][pc].mina = true;
		for(i=-1;i<=1;i++)
			for(j=-1;j<=1;j++) {
				dr = pr + i;
				dc = pc + j;
				if( dr >= 0 && dc >= 0 && dr < n && dc < n ) {
					campo[dr][dc].cont++;
				}
			}
		m++;
	}
}

m = 0;

while(m < mine) {

pr = Math.round((n-1)*Math.random());

pc = Math.round((n-1)*Math.random());

if( !campo[pr][pc].mina ) {

campo[pr][pc].mina = true;

for(i=-1;i<=1;i++)

for(j=-1;j<=1;j++) {

dr = pr + i;

dc = pc + j;

if( dr >= 0 && dc >= 0 && dr < n && dc < n ) {

campo[dr][dc].cont++;

}

m++;

}

Costruiamo ora una funzione ricorsiva per il controllo delle mine medesime.

function controlla(r, c) {
	
	if( campo[r][c].aperta ) return true;
	
	campo[r][c].aperta = true;
	cAperte++;
	
	$('.cella[data-row='+r+'][data-col='+c+']').html(campo[r][c].cont ? campo[r][c].cont : "&nbsp;");
	$('.cella[data-row='+r+'][data-col='+c+']').addClass("aperta");
	
	if( campo[r][c].cont ) 
		$('.cella[data-row='+r+'][data-col='+c+']').addClass("colore-" + (campo[r][c].cont<4?campo[r][c].cont:4));
	
	if( !campo[r][c].mina && !campo[r][c].cont ) {
		
		for(var dr=r-1;dr<=r+1;dr++)
			for(var dc=c-1;dc<=c+1;dc++)
				if(dc >= 0 && dr >= 0 && dc < n && dr < n)
					controlla(dr,dc);
				
	} else if( campo[r][c].mina ) {
		// qui mettiamo la mina
		$('.cella[data-row='+r+'][data-col='+c+']').html('<i class="fa fa-bomb"></i>');
		$('.cella[data-row='+r+'][data-col='+c+']').addClass("mina");
		return false;
	}
	
	return true;
	
}

function controlla(r, c) {

if( campo[r][c].aperta ) return true;

campo[r][c].aperta = true;

cAperte++;

$('.cella[data-row='+r+'][data-col='+c+']').html(campo[r][c].cont ? campo[r][c].cont : " ");

$('.cella[data-row='+r+'][data-col='+c+']').addClass("aperta");

if( campo[r][c].cont )

$('.cella[data-row='+r+'][data-col='+c+']').addClass("colore-" + (campo[r][c].cont<4?campo[r][c].cont:4));

if( !campo[r][c].mina && !campo[r][c].cont ) {

for(var dr=r-1;dr<=r+1;dr++)

for(var dc=c-1;dc<=c+1;dc++)

if(dc >= 0 && dr >= 0 && dc < n && dr < n)

controlla(dr,dc);

} else if( campo[r][c].mina ) {

// qui mettiamo la mina

$('.cella[data-row='+r+'][data-col='+c+']').html('<i class="fa fa-bomb"></i>');

$('.cella[data-row='+r+'][data-col='+c+']').addClass("mina");

return false;

}

return true;

}

Aggiungiamo anche una funzione per quando il gioco sarà finito e vorremo visualizzare tutte le mine:

function scopriMine() {
	for(var r = 0; r < n; r++)
		for(var c = 0; c < n; c++) 
			if(campo[r][c].mina) {
				campo[r][c].aperta = true;
				$('.cella[data-row='+r+'][data-col='+c+']').html('<i class="fa fa-bomb"></i>');
				$('.cella[data-row='+r+'][data-col='+c+']').addClass("mina");
			}
}

function scopriMine() {

for(var r = 0; r < n; r++)

for(var c = 0; c < n; c++)

if(campo[r][c].mina) {

campo[r][c].aperta = true;

$('.cella[data-row='+r+'][data-col='+c+']').html('<i class="fa fa-bomb"></i>');

$('.cella[data-row='+r+'][data-col='+c+']').addClass("mina");

}

A questo punto aggiungiamo una funzione per consentire il click sulle singole caselle:

$('.cella').click(function() {
	if( gioco ) {
		var r = parseInt($(this).attr("data-row"));
		var c = parseInt($(this).attr("data-col"));
		if( !controlla(r,c) ) {
			// ha perso
			gioco = false;
			$('#stato').html("Hai perso!");
		} else if( n*n - cAperte <= mine ) {
			// hai vinto
			gioco = false;
			$('#stato').html("Hai vinto!");
		}
		if( !gioco ) scopriMine();
	} else {
		alert("Gioco finito!");
	}
});

$('.cella').click(function() {

if( gioco ) {

var r = parseInt($(this).attr("data-row"));

var c = parseInt($(this).attr("data-col"));

if( !controlla(r,c) ) {

// ha perso

gioco = false;

$('#stato').html("Hai perso!");

} else if( n*n - cAperte <= mine ) {

// hai vinto

gioco = false;

$('#stato').html("Hai vinto!");

}

if( !gioco ) scopriMine();

} else {

alert("Gioco finito!");

}

});

E una per aggiungere le bandierine:

$('.cella').contextmenu(function(e) {
	e.stopPropagation();
	e.preventDefault();
	var r = parseInt($(this).attr("data-row"));
	var c = parseInt($(this).attr("data-col"));
	if( !campo[r][c].aperta ) {
		if( campo[r][c].flag ) $(this).html('&nbsp;');
		else $(this).html('<i class="fa fa-flag"></i>');
		campo[r][c].flag = !campo[r][c].flag;
	}
});

$('.cella').contextmenu(function(e) {

e.stopPropagation();

e.preventDefault();

var r = parseInt($(this).attr("data-row"));

var c = parseInt($(this).attr("data-col"));

if( !campo[r][c].aperta ) {

if( campo[r][c].flag ) $(this).html(' ');

else $(this).html('<i class="fa fa-flag"></i>');

campo[r][c].flag = !campo[r][c].flag;

}

});

Il file JavaScript nel suo complesso sarà simile al seguente:

class Cella {
	constructor(mina) {
		this.mina = mina;
		this.aperta = false;
		this.cont = 0;
		this.flag = false;
	}
}

var n = 10;
var mine = 10;
var campo = [];
var cAperte = 0;
var gioco = true;

$(document).ready(function() {
	
	$('#griglia').css("height",$('#griglia').width()+"px");
	
	for(r = 0; r < n; r++) {
		campo[r] = [];
		for(c = 0; c < n; c++) {
			campo[r][c] = new Cella(false);
			$('#griglia').append('<div class="cella" data-row="'+r+'" data-col="'+c+'">&nbsp;</div>');
		}
		//$('#griglia').append("<br>");
	}


	$('.cella').css("line-height",$('.cella').width()+"px");
	$('.cella').css("font-size",(32/50)*$('.cella').width()+"px");

	m = 0;
	while(m < mine) {
		pr = Math.round((n-1)*Math.random());
		pc = Math.round((n-1)*Math.random());
		if( !campo[pr][pc].mina ) {
			campo[pr][pc].mina = true;
			for(i=-1;i<=1;i++)
				for(j=-1;j<=1;j++) {
					dr = pr + i;
					dc = pc + j;
					if( dr >= 0 && dc >= 0 && dr < n && dc < n ) {
						campo[dr][dc].cont++;
					}
				}
			m++;
		}
	}

	function controlla(r, c) {
		
		if( campo[r][c].aperta ) return true;
		
		campo[r][c].aperta = true;
		cAperte++;
		
		$('.cella[data-row='+r+'][data-col='+c+']').html(campo[r][c].cont ? campo[r][c].cont : "&nbsp;");
		$('.cella[data-row='+r+'][data-col='+c+']').addClass("aperta");
		
		if( campo[r][c].cont ) 
			$('.cella[data-row='+r+'][data-col='+c+']').addClass("colore-" + (campo[r][c].cont<4?campo[r][c].cont:4));
		
		if( !campo[r][c].mina && !campo[r][c].cont ) {
			
			for(var dr=r-1;dr<=r+1;dr++)
				for(var dc=c-1;dc<=c+1;dc++)
					if(dc >= 0 && dr >= 0 && dc < n && dr < n)
						controlla(dr,dc);
					
		} else if( campo[r][c].mina ) {
			// qui mettiamo la mina
			$('.cella[data-row='+r+'][data-col='+c+']').html('<i class="fa fa-bomb"></i>');
			$('.cella[data-row='+r+'][data-col='+c+']').addClass("mina");
			return false;
		}
		
		return true;
		
	}

	function scopriMine() {
		for(var r = 0; r < n; r++)
			for(var c = 0; c < n; c++) 
				if(campo[r][c].mina) {
					campo[r][c].aperta = true;
					$('.cella[data-row='+r+'][data-col='+c+']').html('<i class="fa fa-bomb"></i>');
					$('.cella[data-row='+r+'][data-col='+c+']').addClass("mina");
				}
	}

	$('.cella').click(function() {
		if( gioco ) {
			var r = parseInt($(this).attr("data-row"));
			var c = parseInt($(this).attr("data-col"));
			if( !controlla(r,c) ) {
				// ha perso
				gioco = false;
				$('#stato').html("Hai perso!");
			} else if( n*n - cAperte <= mine ) {
				// hai vinto
				gioco = false;
				$('#stato').html("Hai vinto!");
			}
			if( !gioco ) scopriMine();
		} else {
			alert("Gioco finito!");
		}
	});

	$('.cella').contextmenu(function(e) {
		e.stopPropagation();
		e.preventDefault();
		var r = parseInt($(this).attr("data-row"));
		var c = parseInt($(this).attr("data-col"));
		if( !campo[r][c].aperta ) {
			if( campo[r][c].flag ) $(this).html('&nbsp;');
			else $(this).html('<i class="fa fa-flag"></i>');
			campo[r][c].flag = !campo[r][c].flag;
		}
	});
	
	
});

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

class Cella {

constructor(mina) {

this.mina = mina;

this.aperta = false;

this.cont = 0;

this.flag = false;

}

var n = 10;

var mine = 10;

var campo = [];

var cAperte = 0;

var gioco = true;

$(document).ready(function() {

$('#griglia').css("height",$('#griglia').width()+"px");

for(r = 0; r < n; r++) {

campo[r] = [];

for(c = 0; c < n; c++) {

campo[r][c] = new Cella(false);

$('#griglia').append('<div class="cella" data-row="'+r+'" data-col="'+c+'"> </div>');

}

//$('#griglia').append("<br>");

}

$('.cella').css("line-height",$('.cella').width()+"px");

$('.cella').css("font-size",(32/50)*$('.cella').width()+"px");

m = 0;

while(m < mine) {

pr = Math.round((n-1)*Math.random());

pc = Math.round((n-1)*Math.random());

if( !campo[pr][pc].mina ) {

campo[pr][pc].mina = true;

for(i=-1;i<=1;i++)

for(j=-1;j<=1;j++) {

dr = pr + i;

dc = pc + j;

if( dr >= 0 && dc >= 0 && dr < n && dc < n ) {

campo[dr][dc].cont++;

}

m++;

}

function controlla(r, c) {

if( campo[r][c].aperta ) return true;

campo[r][c].aperta = true;

cAperte++;

$('.cella[data-row='+r+'][data-col='+c+']').html(campo[r][c].cont ? campo[r][c].cont : " ");

$('.cella[data-row='+r+'][data-col='+c+']').addClass("aperta");

if( campo[r][c].cont )

$('.cella[data-row='+r+'][data-col='+c+']').addClass("colore-" + (campo[r][c].cont<4?campo[r][c].cont:4));

if( !campo[r][c].mina && !campo[r][c].cont ) {

for(var dr=r-1;dr<=r+1;dr++)

for(var dc=c-1;dc<=c+1;dc++)

if(dc >= 0 && dr >= 0 && dc < n && dr < n)

controlla(dr,dc);

} else if( campo[r][c].mina ) {

// qui mettiamo la mina

$('.cella[data-row='+r+'][data-col='+c+']').html('<i class="fa fa-bomb"></i>');

$('.cella[data-row='+r+'][data-col='+c+']').addClass("mina");

return false;

}

return true;

}

function scopriMine() {

for(var r = 0; r < n; r++)

for(var c = 0; c < n; c++)

if(campo[r][c].mina) {

campo[r][c].aperta = true;

$('.cella[data-row='+r+'][data-col='+c+']').html('<i class="fa fa-bomb"></i>');

$('.cella[data-row='+r+'][data-col='+c+']').addClass("mina");

}

$('.cella').click(function() {

if( gioco ) {

var r = parseInt($(this).attr("data-row"));

var c = parseInt($(this).attr("data-col"));

if( !controlla(r,c) ) {

// ha perso

gioco = false;

$('#stato').html("Hai perso!");

} else if( n*n - cAperte <= mine ) {

// hai vinto

gioco = false;

$('#stato').html("Hai vinto!");

}

if( !gioco ) scopriMine();

} else {

alert("Gioco finito!");

}

});

$('.cella').contextmenu(function(e) {

e.stopPropagation();

e.preventDefault();

var r = parseInt($(this).attr("data-row"));

var c = parseInt($(this).attr("data-col"));

if( !campo[r][c].aperta ) {

if( campo[r][c].flag ) $(this).html(' ');

else $(this).html('<i class="fa fa-flag"></i>');

campo[r][c].flag = !campo[r][c].flag;

}

});

Affinché il tutto funzioni abbiamo bisogno anche di un po’ di CSS:

#stato {
	font-size: 32px;
	text-align: center;
	font-family: 'Roboto', sans-serif;
	width: 600px;
}
#griglia {
	width: 600px;
	height: 600px;
}
.cella {
    border: 4px outset #bbb;
    display: inline-block;
    width: 50px;
    height: 50px;
    background-color: #ccc;
    cursor: pointer;
	text-align: center;
	margin: 1px;
	font-family: 'Roboto', sans-serif;
	font-weight: 700;
	font-size: 32px;
	position: relative;
	vertical-align: middle;
}
.cella i {
	position: absolute;
	transform: translate(50%,-50%);
	top: 50%;
	right: 50%;
}
.cella:hover {
	background-color: #aaa;
}
.aperta {
	background-color: #fff;
}
.colore-1 {color: blue;}
.colore-2 {color: green;}
.colore-3 {color: red;}
.colore-4 {color: purple;}
.mina {
	background-color: rgb(255,0,0);
	color: #000;
}

#stato {

font-size: 32px;

text-align: center;

font-family: 'Roboto', sans-serif;

width: 600px;

}

#griglia {

width: 600px;

height: 600px;

}

.cella {

border: 4px outset #bbb;

display: inline-block;

width: 50px;

height: 50px;

background-color: #ccc;

cursor: pointer;

text-align: center;

margin: 1px;

font-family: 'Roboto', sans-serif;

font-weight: 700;

font-size: 32px;

position: relative;

vertical-align: middle;

}

.cella i {

position: absolute;

transform: translate(50%,-50%);

top: 50%;

right: 50%;

}

.cella:hover {

background-color: #aaa;

}

.aperta {

background-color: #fff;

}

.colore-1 {color: blue;}

.colore-2 {color: green;}

.colore-3 {color: red;}

.colore-4 {color: purple;}

.mina {

background-color: rgb(255,0,0);

color: #000;

}

E il gioco è fatto.

Qui è possibile trovare una versione funzionante del gioco (con qualche aggiunta extra).

[python] Classe in Python per accedere con pyodbc ad un database MS Access

Vediamo un semplice esempio di una classe costruita in Python per accedere ad un database MS Access (*.mdb, *.accdb) utilizzando la libreria pyodbc.

Anzitutto procuriamoci pyodbc utilizzando PIP

pip install pyodbc

1	pip install pyodbc

Creiamo la nostra classe nella maniera seguente (nel mio caso creerò un file chiamato accessdb.py):

import pyodbc

class AccessDB():

    def __init__(s,cs):
        s.__cs = cs
        s.__conn = None

        s.__connect()

    def __connect(s):
        s.__conn = pyodbc.connect(s.__cs)

    def In(s,sql,*vals):
        cursor = s.__conn.cursor()
        cursor.execute(sql,vals)
        cursor.execute("SELECT @@IDENTITY")
        lastid = cursor.fetchone()[0]
        s.__conn.commit()
        return lastid

    def Out(s,sql,*vals):
        cursor = s.__conn.cursor()
        cursor.execute(sql,vals)
        risultato = []
        for riga in cursor.fetchall():
            tmp = {}
            for i, col in enumerate(cursor.description):
                tmp[col[0]] = riga[i]
            risultato.append(tmp)
        return risultato

    def __del__(s):
        s.__conn.close()

import pyodbc

class AccessDB():

def __init__(s,cs):

s.__cs = cs

s.__conn = None

s.__connect()

def __connect(s):

s.__conn = pyodbc.connect(s.__cs)

def In(s,sql,*vals):

cursor = s.__conn.cursor()

cursor.execute(sql,vals)

cursor.execute("SELECT @@IDENTITY")

lastid = cursor.fetchone()[0]

s.__conn.commit()

return lastid

def Out(s,sql,*vals):

cursor = s.__conn.cursor()

cursor.execute(sql,vals)

risultato = []

for riga in cursor.fetchall():

tmp = {}

for i, col in enumerate(cursor.description):

tmp[col[0]] = riga[i]

risultato.append(tmp)

return risultato

def __del__(s):

s.__conn.close()

Il metodo In restituisce, se presente, l’ultimo ID inserito. Il metodo Out restituisce una lista di dizionari, con i nomi delle colonne e i valori per ogni riga.

Immaginiamo di posizionare il suddetto file in una sottocartella librerie.

Possiamo usare la classe nella maniera seguente:

from librerie.accessdb import AccessDB


db = AccessDB(r'Driver={Microsoft Access Driver (*.mdb, *.accdb)};DBQ=C:\cartella del database\scuola.accdb')

sid = db.In("INSERT INTO studenti (nome,cognome) VALUES('Zeno','Neri')")

print(sid)

studenti = db.Out("SELECT * FROM studenti")

print(studenti)

for s in studenti:
    print(s["nome"])


del db

from librerie.accessdb import AccessDB

db = AccessDB(r'Driver={Microsoft Access Driver (*.mdb, *.accdb)};DBQ=C:\cartella del database\scuola.accdb')

sid = db.In("INSERT INTO studenti (nome,cognome) VALUES('Zeno','Neri')")

print(sid)

studenti = db.Out("SELECT * FROM studenti")

print(studenti)

for s in studenti:

print(s["nome"])

del db

ATTENZIONE! Nella stringa di connessione va inserito il percorso assoluto del file del database.