Petar Karan

[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;
	}
}

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

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);
	}

1

2

3

4

5

6

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());
				}
			}
		}
		
	}
	
}

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

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!");
			
		}
		
	});
	
});

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

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;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

#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>

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

<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>

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

<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;
	}
}

1

2

3

4

5

6

7

8

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>");
}

1

2

3

4

5

6

7

8

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++;
	}
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

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;
	
}

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

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");
			}
}

1

2

3

4

5

6

7

8

9

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!");
	}
});

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

$('.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;
	}
});

1

2

3

4

5

6

7

8

9

10

11

$('.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;
		}
	});
	
	
});

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

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;
}

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

#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()

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

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

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

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.

[FIFA22] Steam errore – Esci da eventuali giochi o strumenti in esecuzione prima di provare a verificare i tuoi file locali (RISOLTO)

Problema: Cercando di avviare FIFA 22 da Steam appare il seguente messaggio di errore “Esci da eventuali giochi o strumenti in esecuzione prima di provare a verificare i tuoi file locali” e il gioco non si avvia.

Soluzione: Disinstallare Origin e riavviare il gioco.

Quando si cerca di avviare FIFA 22 da Steam appare un popup di errore come il seguente.

Per quanto si possa cercare di riparare i file e avviare il gioco, quest’ultimo semplicemente non parte.

Per risolvere il problema è sufficiente (e necessario purtroppo!) disinstallare Origin.

Andare su App e funzionalità e individuare l’installazione di Origin.

Selezionare e scegliere disinstalla. Si aprirà una finestra come la seguente.

Confermare la disinstallazione.

Una volta completata avviare il gioco, comparirà una schermata come la seguente per l’installazione di OriginThinSetup.

Confermare cambiando eventualmente il percorso di installazione.

Adesso possiamo tornare a giocare a FIFA 22.

[risolto] Plesk: Unable to manage service by phpinimng: (‘start’, ‘plesk-php73-fpm’). Service plesk-php73-fpm is down after attempt to start it

Problema: Impossibile avviare il servizio PHP-FPM 7.3.5 su Plesk. Viene visualizzato un errore del genere Unable to manage service by phpinimng: ('start', 'plesk-php73-fpm'). Service plesk-php73-fpm is down after attempt to start it

Soluzione: Questo problema dipende spesso da errori di configurazione nei file che si trovano in /opt/plesk/php/7.3/etc/php-fpm.d/ oppure dalla presenza di file orfani, dopo la cancellazione di un servizio. Controllare tutti i file e rimuovere gli eventuali orfani (questa è la prima soluzione da valutare).

Nel mio caso specifico, a seguito della cancellazione di un sottodominio, era rimasto il file di configurazione del sottodominio stesso.

Entrando in SSH ed eseguendo rm /opt/plesk/php/7.3/etc/php-fpm.d/sottodominio.orfano.conf il problema si è risolto. E’ stato sufficiente riavviare il servizio e riapplicare la configurazione corrente su uno qualsiasi dei domini attivi che utilizzano il PHP 7.3

[virtualbox] Failed to query SMC value from the host (VERR_INVALID_HANDLE)

Problema: Avviare una macchina virtuale di MacOS su VirtualBox produce l’errore Failed to query SMC value from the host (VERR_INVALID_HANDLE). Un altro sintomo è una generale lentezza di tutte le macchine virtuali su VirtualBox.

Soluzione: Questo errore è dovuto probabilmente a Hyper-V che va disabilitato all’avvio di Windows. Per farlo è sufficiente aprire il prompt dei comandi come amministratore e digitare bcdedit /set hypervisorlaunchtype off. Riavviare infine il PC.

La procedura può essere eseguita anche dalla PowerShell.

Cliccare col destro sul tasto di avvio di Windows e selezionare Windows PowerShell (Amministratore)

Digitare bcdedit /set hypervisorlaunchtype off

Premere INVIO.

Riavviare il PC.

[c#] Semplice classe per gestire connessione e query su un database MySQL

Il nostro scopo è scrivere una semplice classe in C# che permetta di gestire l’inserimento e la lettura dei dati dal database. La caratteristica saliente che ci interessa in questo caso è l’accesso ai dati, in fase di lettura, tramite una List<ListDictionary>, che consente di trattare i risultati come una lista di dizionari.

La classe che vogliamo creare permetterà un utilizzo simile a questo:

using (MySQLdb mysql = new MySQLdb(@"server=localhost;userid=root;password=;database=esempio"))
{
    mysql.setQuery("INSERT INTO studenti(nome,cognome) VALUES(@nome,@cognome)")
        .addParameter("@nome","Gianpiero")
        .addParameter("@cognome","Franchi").In();

    List<ListDictionary> studenti = mysql.setQuery("SELECT * FROM studenti WHERE nome = @nome OR 1")
        .addParameter("@nome","Mario").Out();

    foreach(ListDictionary s in studenti)
    {
        Console.WriteLine(s["nome"]);
    }
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

using (MySQLdb mysql = new MySQLdb(@"server=localhost;userid=root;password=;database=esempio"))

{

mysql.setQuery("INSERT INTO studenti(nome,cognome) VALUES(@nome,@cognome)")

.addParameter("@nome","Gianpiero")

.addParameter("@cognome","Franchi").In();

List<ListDictionary> studenti = mysql.setQuery("SELECT * FROM studenti WHERE nome = @nome OR 1")

.addParameter("@nome","Mario").Out();

foreach(ListDictionary s in studenti)

{

Console.WriteLine(s["nome"]);

}

La classe sarà formata invece nel modo seguente:

namespace DatabaseMySQL
{
    public class MySQLdb : IDisposable
    {
        private bool isDisposed = false;
        private string connectionString { get; set; }
        private MySqlConnection connection;
        private MySqlCommand command;

        public MySQLdb(string connectionString)
        {
            this.connectionString = connectionString;

            this.connect();
        }

        ~MySQLdb()
        {
            Dispose(false);
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected void Dispose(bool disposing)
        {
            if(!isDisposed && disposing)
            {
                if(this.command != null) this.command.Dispose();
                if (this.connection != null) this.connection.Close();
            }
            isDisposed = true;
        }

        private void connect()
        {
            this.connection = new MySqlConnection(this.connectionString);
            this.connection.Open();
        }

        public MySQLdb setQuery(string query)
        {
            this.command = new MySqlCommand(query, this.connection);
            return this;
        }

        public MySQLdb addParameter(string name, string value)
        {
            if (this.command != null)
            {
                this.command.Parameters.AddWithValue(name, value);
            }
            return this;
        }

        public List<ListDictionary> Out()
        {
            List<ListDictionary> risultato = new List<ListDictionary>();
            if (this.command != null)
            {
                this.command.Prepare();
                using (MySqlDataReader reader = this.command.ExecuteReader())
                {
                    while (reader.Read())
                    {
                        ListDictionary dict = new ListDictionary();
                        for (int col = 0; col < reader.FieldCount; col++)
                        {
                            dict.Add(reader.GetName(col), reader.GetValue(col).ToString());
                        }
                        risultato.Add(dict);
                    }
                }
                this.command.Dispose();
            }
            return risultato;
        }

        public long In()
        {
            if (this.command != null)
            {
                this.command.Prepare();
                this.command.ExecuteNonQuery();
                long lastId = this.command.LastInsertedId;
                this.command.Dispose();
                return lastId;
            }
            return -1;
        }
    }
}

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

namespace DatabaseMySQL

{

public class MySQLdb : IDisposable

{

private bool isDisposed = false;

private string connectionString { get; set; }

private MySqlConnection connection;

private MySqlCommand command;

public MySQLdb(string connectionString)

{

this.connectionString = connectionString;

this.connect();

}

~MySQLdb()

{

Dispose(false);

}

public void Dispose()

{

Dispose(true);

GC.SuppressFinalize(this);

}

protected void Dispose(bool disposing)

{

if(!isDisposed && disposing)

{

if(this.command != null) this.command.Dispose();

if (this.connection != null) this.connection.Close();

}

isDisposed = true;

}

private void connect()

{

this.connection = new MySqlConnection(this.connectionString);

this.connection.Open();

}

public MySQLdb setQuery(string query)

{

this.command = new MySqlCommand(query, this.connection);

return this;

}

public MySQLdb addParameter(string name, string value)

{

if (this.command != null)

{

this.command.Parameters.AddWithValue(name, value);

}

return this;

}

public List<ListDictionary> Out()

{

List<ListDictionary> risultato = new List<ListDictionary>();

if (this.command != null)

{

this.command.Prepare();

using (MySqlDataReader reader = this.command.ExecuteReader())

{

while (reader.Read())

{

ListDictionary dict = new ListDictionary();

for (int col = 0; col < reader.FieldCount; col++)

{

dict.Add(reader.GetName(col), reader.GetValue(col).ToString());

}

risultato.Add(dict);

}

this.command.Dispose();

}

return risultato;

}

public long In()

{

if (this.command != null)

{

this.command.Prepare();

this.command.ExecuteNonQuery();

long lastId = this.command.LastInsertedId;

this.command.Dispose();

return lastId;

}

return -1;

}

[wordpress] Errore RSS: WP HTTP Error: cURL error 60: SSL certificate problem: certificate has expired

Questo errore si presenta nel feed RSS di WordPress a causa di un certificato intermedio scaduto utilizzato da cURL.

Il problema è spesso causato da LetEncrypt. Per risolvere il problema è sufficiente disabilitare il certificato DST CA X3 scaduto.

Per farlo su Ubuntu digitiamo nel terminale i seguenti due comandi:

sed -i 's/mozilla\/DST_Root_CA_X3.crt/!mozilla\/DST_Root_CA_X3.crt/g' /etc/ca-certificates.conf

update-ca-certificates

[risolto] TekkenGame-Win64-Shipping.exe crash con eccezione 0xc0000005

Problema: Tekken 7 su PC (Steam) va in crash con codice di eccezione 0xc0000005 (nel mio caso succedeva quando si tentava una partita VS in locale)

Soluzione: Da Steam verificare l’integrità dei file di gioco.

Tekken 7, installato sul PC da Steam, comincia a crashare senza motivo apparente quando si sta per avviare una partita VS. Dopo aver provato in vano a modificare la risoluzione (passando anche dalla modalità schermo intero a quella borderless e infine a quella a finestra), modificare l’assetto grafico e perfino disattivare l’antivirus, ho eseguito la verifica di integrità dei file di gioco su Steam e questo ha risolto il problema.

L’errore nel registro di Windows dovrebbe apparire come qualcosa del genere:

Nome dell'applicazione che ha generato l'errore: TekkenGame-Win64-Shipping.exe, versione: 1.0.1.0, timestamp: 0x61fb9339
Nome del modulo che ha generato l'errore: TekkenGame-Win64-Shipping.exe, versione: 1.0.1.0, timestamp: 0x61fb9339
Codice eccezione: 0xc0000005
Offset errore 0x0000000000745b24
ID processo che ha generato l'errore: 0x15fc

Per risolvere il problema è dunque sufficiente andare nella libreria di Steam.

Cliccare col destro sul gioco e poi su Proprietà

Nella finestra delle proprietà spostarsi su File Locali.

Infine cliccare su Verifica integrità dei file di gioco…

Il processo richiederà qualche minuto probabilmente e dopodiché il problema dovrebbe essere risolto.