>> ROB BOWDEN: Ciao.
Io sono Rob, e spero che il vostro gioco per il gioco del 15.
Ora, ci sono quattro funzioni che servono di attuare in questo programma - init,
disegnare, spostare, e ha vinto.
Quindi, diamo un'occhiata a init.
>> Qui, vediamo la prima cosa che siamo intenzione di fare è dichiarare una variabile
chiamato contatore.
Sta andando essere inizializzato ai tempi d d meno 1.
Ricorda che d è la dimensione del nostro consiglio.
Come init è andare a lavorare è che sta andando per scorrere l'intero consiglio
e stiamo per cominciare in alto a sinistra.
>> E diciamo solo noi avere un 4 per 4 a bordo.
Così in alto a sinistra siamo andare a dire è 15.
E poi stiamo solo andando a contare attraverso le tavole, dicendo: 15, 14, 13,
12, 11, 10, 9, 8, 7, 6, 5, 4, e così via.
Così in alto a sinistra, ci aspettiamo di essere d volte d meno 1, che nel 4 da 4
caso sta per essere 16 meno 1, che è correttamente 15.
>> Ed ora ecco dove stiamo andando a scorrere l'intera scheda.
E abbiamo intenzione di impostare ogni posizione in la scheda al valore corrente di
il nostro contatore, e poi contatore sta andando per diminuire, in modo che la prossima
posizione si raggiunge sta per avere Contatore essere uno in meno
la posizione precedente.
Così inizialmente avevamo 15 e diminuire contatore.
Allora stiamo andando assegnare 14 alla posizione successiva, contatore decremento,
e stiamo per assegnare 13, e così via.
>> Infine, abbiamo bisogno di gestire quell'angolo caso in cui, se la scheda ha un ancora
dimensione, poi basta fare 15, 14, 13, 12, tutta la strada fino a 3, 2, 1, è
intenzione di lasciare noi con una scheda irrisolvibile.
E dobbiamo scambiare l'1 e il 2.
Quindi, se d mod 2 è uguale a 0, che è come stiamo andando a controllare
per vedere se è ancora.
Se d mod 2 è uguale a 0, poi in fila d meno 1, che è la riga di fondo, e
posizione d meno 2, o una colonna d meno 2, stiamo andando a impostare che a 2, e
colonna d meno 3 siamo andando a impostare a 1.
Quindi questo è solo invertendo dove l'1 e 2 attualmente sono.
>> Infine, stiamo andando a impostare il molto in basso a destra pari a vuoto, dove
blank è stato definito hash in alto come 0.
Quindi, che non era strettamente necessario, poiché questo ciclo for sta per avere
impostare il basso a destra per 0, poiché contatore sarà naturalmente raggiungere lo 0.
Ma che si basa su di noi sapendo che blank è stato eseguito l'hashing per trovare un 0.
Se vado in questo programma e poi modificare vuota nella parte superiore a 100, essa
dovrebbe ancora funzionare.
>> Quindi questo è solo fare in modo che il in basso a destra è in realtà uguale al nostro
valore del bianco.
Infine, abbiamo due variabili globali, così blank i e j vuoto, e vediamo
quelli dichiarati in alto.
E abbiamo intenzione di usare quei due globale variabili per tenere traccia del
posizione del vuoto, in modo che non lo facciamo bisogno di guardare attraverso l'intero
bordo per trovare il vuoto di ogni singolo volta cerchiamo di fare una mossa.
Quindi la posizione del fustellato è sempre sta per iniziare in basso a destra.
Così basso a destra è data da indici d meno 1, d meno 1.
Quindi, questo è init.
>> Ora passiamo a disegnare.
Quindi, pareggio sta per essere simile dove stiamo andando a scorrere
su tutta la scheda.
E vogliamo solo stampare il valore che è in ogni posizione del consiglio di amministrazione.
Così qui, stiamo stampando il valore che è in ogni posizione del consiglio di amministrazione.
E notiamo che stiamo facendo -.
E questo è solo raccontare printf che indipendentemente se si tratta di una sola cifra o
numero a due cifre, vogliamo ancora per prendere due colonne nella stampa fuori,
in modo che se abbiamo due cifre e uno numeri a due cifre nella stessa scheda, il nostro
bordo sarà ancora un aspetto gradevole e la piazza.
>> Così vogliamo fare che per ogni valore nella tavola, tranne per il bianco.
Quindi, se la posizione nel consiglio uguale il vuoto, poi abbiamo specificamente
vuole stampare solo una sottolineatura per rappresentare il vuoto, anziché
qualunque sia il valore della vuoto in realtà è.
>> Infine, vogliamo stampare una nuova linea.
Si noti che questo è ancora dentro il ciclo for esterno, ma al di fuori
l'interno ciclo for.
Dal momento che questo ciclo for esterno è iterazione su tutte le righe, e quindi questo è printf
andare in stampa solo una nuova linea, in modo da passare per stampare la riga successiva.
E questo è tutto per il pareggio.
>> Così, ora passiamo a muoversi.
Ora, passiamo mossa, la tessera che la l'utente viene inserito nel gioco - che
inserisci la tessera che vogliono muoversi - e si suppone di restituire un bool, così
true o false, a seconda se tale mossa era in realtà
valido - se tale tessera può essere spostato nello spazio vuoto.
>> Così qui, dichiariamo una variabile locale, tile_1 e tile_j, che stanno andando a
essere simile a blank_i e blank_j, tranne che sta andando a tenere traccia del
la posizione della tessera.
Ora qui, stiamo andando a utilizzare blank_i e blank_j e dire va bene, così
ecco il vuoto sulla scheda.
>> Ora, è la piastrella sopra il vuoto?
È la piastrella a fianco del fustellato?
È la tegola a destra dello sbozzato?
È la tegola sotto il vuoto?
Quindi, se la tessera è in una di queste posizioni, allora sappiamo che la piastrella
può essere spostato nel posto vuoto e il vuoto può essere spostato in cui la
tegola è attualmente.
>> Ecco, diciamo che se la scheda in posizione blank_i meno 1 blank_j.
Quindi questo sta dicendo è la piastrella al di sopra del vuoto attuale?
E se è così, stiamo andando a ricordare cioè la posizione della tessera.
La tegola è in posizione blank_i meno 1 e blank_j.
ora prima, abbiamo anche questo controllo proprio qui, così blank_i è
maggiore di 0.
>> Perché vogliamo farlo?
Beh, se il vuoto è nella riga superiore del consiglio di amministrazione, quindi noi non vogliamo
guardare al di sopra del vuoto per la piastrella dal non c'è nulla sopra il top
riga della scheda.
In questo modo si potrebbe finire per ottenere qualcosa come un errore di segmentazione o
il programma potrebbe funzionare in modi inaspettati.
Quindi, questo è fare in modo che non lo facciamo guardare in luoghi che non sono validi.
>> Ora stiamo andando a fare la stessa cosa per tutte le altre combinazioni possibili.
Così qui, stiamo cercando di sotto del vuoto per vedere se questa è la piastrella.
E dobbiamo anche fare in modo che siamo non sulla riga inferiore, oppure noi
non dovrebbe cercare la piastrella.
Qui stiamo andando a guardare a sinistra il vuoto per vedere se è la piastrella.
E non dobbiamo guardare verso sinistra se siamo nella colonna più a sinistra.
E qui stiamo andando a guardare al destra del vuoto, e non dovremmo
andare a destra se siamo nella colonna di destra.
>> Quindi, se nessuna di queste cose fosse vera, significa che la tessera non era adiacente
il vuoto e possiamo tornare false.
La mossa non era valida.
Ma, se una di queste fosse vero, allora a questo punto, sappiamo che tile_i e
tile_j sono uguali al la posizione della tessera.
E così, possiamo aggiornare il bordo posizioni tile_i e tile_j.
Sappiamo che il nuovo valore sarà il vuoto e che la posizione blank_i
blank_j, che era l'originale blank - sappiamo che la tegola sta per
trasferirsi lì.
>> Si noti che in realtà non dobbiamo fare un reale di swap qui, dal momento che sappiamo che la
valori che devono essere inseriti in tali posizioni.
Non abbiamo bisogno di un temporaneo variabile intorno.
>> Infine, dobbiamo ricordare che siamo le nostre variabili globali che sono
tenere traccia della posizione del vuoto.
Quindi vogliamo aggiornare la posizione di il vuoto per essere dove la piastrella
originariamente era.
Infine, torniamo vero in quanto la mossa ha avuto successo.
Ci scambiamo con successo il bianco con la piastrella.
>> Va bene, così finalmente abbiamo necessario verificare vinto.
Così, ha vinto restituisce allo stesso modo un bool dove vero sta a indicare che l'
utente ha vinto la partita.
E falso indica che il gioco è ancora in corso.
L'utente non ha vinto.
Quindi, questo sta per essere praticamente il contrario di init, dove init,
Ricordiamo, inizializziamo la scheda a 15, 14, 13, 12, ecc.
Considerando che ha vinto, vogliamo verificare se il bordo è 1, 2, 3, 4, 5, e così via.
>> Quindi, stiamo andando a inizializzare il contrastare a 1 dato che è quello che la parte superiore
sinistra della scheda dovrebbe essere.
E poi andremo a ciclo su tutta la scheda.
Cerchiamo di ignorare questa condizione per un secondo.
E questa condizione è solo andare a controllo è la scheda in questa posizione
pari ai conti correnti?
Se è così, incrementare il conteggio in modo che la successiva posizione guardiamo è una maggiore
rispetto alla posizione siamo in questo momento.
>> Ecco come si ottiene il in alto a sinistra dovrebbe essere 1.
Incrementare il conteggio a 2.
Guardate la posizione successiva.
È questo 2?
Se è così, incrementare il conteggio a 3.
Posizione successiva, questo 3?
Se è così, incrementare il conteggio a 4, e così via.
Quindi, se c'è qualche posizione sulla scheda che non è uguale a nostro conteggio,
poi vogliamo tornare falso in quanto tale significa che c'è qualche tegola che è
non in posizione corretta.
>> Ecco, che cosa sta facendo questa condizione?
Bene, ricordate che il bianco sia dovrebbe andare in basso a destra.
E il valore del bianco potrebbe non necessariamente uguale al valore della
contatore che sta per essere raggiunto in basso a destra.
Così abbiamo specificamente vogliamo verificare se i uguale uguale d meno 1 e j uguali
uguale d meno 1 - che è tutto dire se si stanno guardando in basso a destra della
il consiglio - poi abbiamo appena voglia di continuare.
Vogliamo ignorare questo particolare iterazione del ciclo for.
>> E così, se riusciamo a superare questo nidificato per il ciclo, il che significa che
non c'era tegola che era in la posizione corretta.
E noi spezziamo fuori dal giro e arriviamo qui, dove possiamo restituire true.
Tutte le mattonelle erano nelle posizioni corrette e ciò significa che l'utente ha
vinto la partita.
E questo è tutto.
Il mio nome è Rob Bowden, e questo era 15.