Vediamo quali sono state le cause di questa conversione.

Io ho sempre giocato su pc, ricordo perfettamente Alley Cat  contenuto su un dischetto da 5 1/4 e visto su un display in bianco e nero, credo che siano passati almeno vent’anni.
Ricordo Commander Keen, Wolf3d, Doom (che da qualche parte ho in giro originale su dischetti), per poi arrivare ad Half Life.
La svolta à arrivata nel 2001 quando ho iniziato a giocare online a Day Of Defeat, con cui passavo le nottate: tutto sommato me la cavicchiavo, tant’è che sono stato membro della prima nazionale italiana.
Ora, quando si gioca così tanto si smette di essere un giocatore occasionale (causal gamer), ma si assumono i connotati tipici di un professionista (pro gamer): il vero player è colui che fragga online e lo fa su pc. Gli altri sono solo casual gamer, la cui utilità è far vendere videogiochi e farsi uccidere sui server da chi ha più esperienza.

Questa mentalità ha due problemi grossi: il primo è di natura economica, giocare su pc costa parecchio perchè bisogna cambiare hardware spesso e in ogni caso non si è mai felici, poi c’è il fatto che i cambiamenti sono visti come drammi perchè muovono parecchio le acque; si può passare da un giorno all’altro da campione a schiappa, soprattutto se non si ha la flessibilità per adattarsi.
Dopo aver passato almeno due anni e 4 versioni del gioco, ho deciso che era giunto il momento di ritirarmi e smettere di giocare in modo così competitivo, non mi sarei mai laureato se avessi continuato a giocare tutte le sere fino a tarda notte e poi alzarmi per andare in università… non ho smesso però di giocare.

Mafia è stato sicuramente uno dei giochi più belli a cui abbia mai giocato, poi ricordo Half Life 2, uno dei giochi più sopravvalutati di tutti i tempi.
L’ultimo computer fisso l’ho comprato nel 2003, spendendo un capitale (circa 1700€) visto che era dotato di molti componenti per il gaming, quali una scheda video di alto livello, un ottimo processore e una quantità di memoria consistente: in un paio di anni tale sistema non era più in grado di reggere gli sparatutto più moderni se configurati a dettaglio alto, così ho deciso di comprare una console.

La scelta è ricaduta sull’Xbox 360 perchè concettualmente è quella più simile ad un pc, con un grande supporto al gioco online; le paure principali derivavano dal sistema di controllo, il pad, che non mi sembrava adatto agli sparatutto, e dai giochi che avevo sempre considerato inferiori rispetto a quelli che si potevano giocare su pc.

Mi sbagliavo completamente.

Arrivata a casa la console, presa nel dicembre 2005 cioè un mese dopo l’uscita, i primi titoli sono stati PGR3 e Call Of Duty 2: il pad non è quella bestia nera che pensavo e ci si poteva divertire anche online!
Prima di rincretinirmi completamente con Guitar Hero, ho comprato praticamente tutti i giochi migliori usciti per questa piattaforma e ora posso affermare che è stato uno dei migliori acquisti degli ultimi anni.
Tutti i problemi di hardware, configurazione e driver sono spariti e non devo più aggiornare il sistema ogni pochi anni; se a questo aggiungiamo un costo iniziale di 400€ il quadro non può che essere roseo.

Tutte le paure si sono rivelate infondate, erano più che altro date dalla diffidenza per un sistema nuovo… certo, magari il pad non è così immediato come un mouse per uno sparatutto, ma se il gioco è ben calibrato il problema non si sente assolutamente (vedere Gears of War o Bioshock); ovviamente nemmeno online vi è il benchè minimo inconveniente visto che tutti giocano con gli stessi mezzi.

Ora per me il pc è un portatile e non più una piattaforma da gioco “seria”, anche se alcuni giochini in Flash riescono a tenermi davanti al monitor per diverse ore.

Oggi, dopo parecchio tempo, è stata una bella giornata così ho fatto il mio classico giretto in moto: partenza da Cernobbio, arrivo a Menaggio dalla Regina, poi si passa da Porlezza, si torna ad Argegno e quindi di nuovo a casa. Sono circa 90 km, ma il traffico oggi era davvero inteso e così ho cercato di capire meglio quali sono i problemi della Regina, strada tanto criticata.

Uno delle cause principali di incidente è l’alta velocità, ma prima bisogna capire bene cosa si intende: il più delle volte chi perde la vita sulla strada stava procedendo ad una velocità molto superiore al limite imposto dalle amministrazioni locali e sicuramente oltre al limite dettato dal buon senso; quindi piazzare un 50 all’ora su una strada dritta perchè qualcuno si è fatto male a 140 è piuttosto stupido.

In particolare credo che sia fondamentale quella che io chiamo la “velocità naturale”, cioè la velocità a cui una persona media percorrerebbe una certa strada senza limite. Mi spiego meglio: se stiamo affrontando una piccola viuzza di paese nessuna persona sana di mente procederebbe a più di 25 all’ora, anche se il limite è più alto, al contrario su un lunghissimo e ampoi rettilineo in mezzo ai campi è molto difficile stare sotto gli 80 all’ora, anche se il limite è più basso.
La tendenza, insomma, è quella di tenere una velocità che non appare pericolosa agli occhi di chi guida, indipendentemente dal limite imposto in quel tratto, ma molte amministrazioni non sembrano averlo capito.

Ipotizziamo che dopo un lungo rettilineo ci sia una curva pericolosa seguita a sua volta da un altro lungo rettilineo. La situazione ideale è quella di avere un limite alto sui due rettilinei e in prossimità della curva uno più basso con un’adeguata segnalazione della svolta, questo modo il pericolo ci viene comunicato e la “velocità naturale” scende di conseguenza, infatti il pensiero è qualcosa del tipo “se prima c’erano i 90 all’ora e ora vedo i 40 con una segnalazione di curva pericolosa, forse qualcosa di pericoloso c’è davvero, meglio rallentare”.
Più pericoloso invece è trovarsi il limite più basso senza la spiegazione, visto che il meccanismo psicologico fa più fatica a scattare, ma magari il dubbio viene e si alza il piede dal gas lo stesso (“perchè si è passati dai 90 ai 40? Rallento un po’, poi vedo”); la situazione peggiore invece è quella con i 40 su tutto il tratto: sul rettilineo tale limite verrà certamente ignorato e arrivati in curva la velocità sarà troppo alta.
Purtroppo quest’ultima eventualità non è così rara…

Tornando alla via Regina, riguardo al tratto tra Cernobbio e Menaggio, in generale i limiti non sono così assurdi come spesso invece si sente dire: in quasi tutti i tratti rettilinei sufficientemente larghi il limite è di 70 km/h, molto vicino alla velocità naturale di sicurezza, mentre il limite scende a 50 in prossimità dei centri abitati, ma ritorna più alto subito dopo.
Un esempio è Brienno, dove ci si trova a 50 km/h per un breve tratto prima della galleria, che è quello più stretto, per poi risalire dalla galleria stessa in poi.
Dovendo assegnare un premio, Carate Urio è sicuramente quello che lo merita, visto che i limiti sono sempre adeguati e ben segnalati, l’esatto contario di Moltrasio: i 50 all’ora subito dopo la galleria sono praticamente impossibili da rispettare, per quanto uno si impegni si troverà ad almeno 10 km/h in più formando alle sue spalle una piccola coda. Vi è la sensazione spiacevole che all’amministrazione del territorio abbia piazzato un limite troppo basso per fare cassa con l’autovelox: non so è così (personalmente non ho mai visto autovelox in quella zona), però non si riesce davvero a rispettarlo; spero che il limite venga alzato a 70 km/h oppure che venga segnalato in modo evidente il pericolo, in modo che la velocità naturale si riporti a 50km/h.

Una delle prime classi che ho definito è stata Monster che, tra le varie cose, espone il metodo draw(surface) per disegnarsi sulla superficie di destinazione, con il relativo test, e ora sto definendo la classe Tower ed anch’essa dovrà essere mostrata a schermo, quindi necessiterà di un metodo di disegno, come indicato dal seguente test:

class TowerTest < Test::Unit::TestCase
 
  def setup
    @tower_image = SurfaceMock.new([20, 20])
    @position = Position.new(100, 200)
   
    @tower = Tower.new(@position, @tower_image)
  end
 
  def test_draw
    destination_surface = SurfaceMock.new([500, 500])
   
    @tower.draw(destination_surface)
   
    assert_equal(destination_surface, @tower_image.target)
    assert_equal([90, 190], @tower_image.destination)
  end
 
end

Il fatto che i due test siano praticamente identici, e quindi esista una duplicazione, ci deve spingere a cercare un modo per rimuoverla anche perché appare evidente che tale duplicazione si troverà anche nelle due classi. Procediamo per passi.

Iniziamo a duplicare il codice tra Monster e Tower in modo da far passare entrambi i test:

class Tower
  def initialize(position, image)
    @image = image
    @position = position
  end
 
  def draw(destination_surface)
    @image.blit( destination_surface, top_left_image_corner() )
  end
 
  private
  def top_left_image_corner()
    new_top = @position.x - @image.height / 2
    new_left = @position.y - @image.width / 2
   
    return [new_top, new_left]
  end
 
end

class Monster
  initialize(initial_health, initial_position, image, speed)
    @image = image
    @position = position
    [...]
  end
 
  def draw(destination_surface)
    @image.blit( destination_surface, top_left_image_corner() )
  end
 
  private
  def top_left_image_corner()
    new_top = @position.x - @image.height / 2
    new_left = @position.y - @image.width / 2
   
    return [new_top, new_left]
  end
 
   [...]
end

In questo caso credo che sia ragionevole dire che sia Tower che Monster siano due Sprite e che il metodo draw sia definito nella superclasse, quindi applichiamo un Extract Superclass a Tower, portando tutto nella nuova classe Sprite.

class Sprite
   

  def initialize(position, image)
    @image = image
    @position = position
  end
 
  def draw(destination_surface)
    @image.blit( destination_surface, top_left_image_corner() )
  end
 
  private
  def top_left_image_corner()
    new_top = @position.x - @image.height / 2
    new_left = @position.y - @image.width / 2
   
    return [new_top, new_left]
  end
 
end

class Tower < Sprite
[...]

end

Testiamo tutto: barra verde. Facciamo lo stesso con Monster e ci accorgiamo che in Sprite bisogna definire l’attributo position, in particolare in lettura deve essere pubblico, mentre in scrittura deve essere disponibile solo alle sotto classi, quindi protected: questo perchè Monster si muove e ha bisogno di aggiornare la posizione (il codice relativo non è stato riportato qui)

class Sprite
 
  public
  attr_reader :position
 
  protected
  attr_writer :position

  [...]

end

class Monster < Sprite
  [...]
end

Lanciamo i test e tutti passano. In questo momento abbiamo tolto la duplicazione dalle classi sotto test, ma non da quelle di test.
Iniziamo a scrivere il test della classe Sprite:

class SpriteTest < Test::Unit::TestCase
 
  def setup
    @image = SurfaceMock.new([20, 20])
    @position = Position.new(100, 200)
   
    @sprite = Sprite.new(@position, @image)
  end
 
  def test_draw
    destination_surface = SurfaceMock.new([500, 500])
   
    @sprite.draw(destination_surface)
   
    assert_equal(destination_surface, @image.target)
    assert_equal([90, 190], @image.destination)
  end
 
end

rendiamo quindi il membro @sprite accessibile sia in scrittura che in lettura dalle sottoclassi e ricordiamoci il principio di sostituzione di Liskov che dice che le sottoclassi non devono invalidare il contratto delle superclassi o, per dirlo in un altro modo, tutti i test validi per la superclasse devono esserlo anche per la sottoclasse. Per definire questa relazione nel programma è sufficiente far estendere ai test delle sottoclassi il test della superclasse; quindi ora modifichiamo MonsterTest e TowerTest, ricordandoci di richiamare sempre il setup e di usare le variabili position e image della superclasse, di assegnare a sprite l’elemento da testare e di cancellare i test duplicati:

class TowerTest < SpriteTest
 
  def setup
    super()

    @tower = Tower.new(self.position, self.image)
    self.sprite = @tower
  end

end

Lanciamo i test e vediamo una barra verde: i test della superclasse vengono lanciati perchè ereditati nella sottoclasse.

Una nota: Sprite e SpriteTest in Java o C# sarebbe state classi astratte, ma in Ruby questo concetto non esiste, per cui sono classi semplici.

Nella pagina spirito del blog troverete le motivazioni che mi hanno spinto ad aprire questo sito, ora spero di avere il tempo di seguirlo a sufficienza e, cosa più importante, qualcosa di sensato da scrivere.