Top Level Namespace

Instance Method Summary collapse

Instance Method Details

#alijo(sigmar, _dado1, _dado2) ⇒ Object

11


93
94
95
96
97
# File 'lib/buscar_tesoros.rb', line 93

def alijo(sigmar, _dado1, _dado2) # 11
  r = %w(gema runa gema gema joya)
  c = [gema_random, runa_random, 'estropeada', gema_random, joya_random]
  r[caras_sigmar.index(sigmar)] + ': ' + c[caras_sigmar.index(sigmar)]
end

#buscar_tesoros(tipo, sigmar, *doble) ⇒ Object

Resultados dependiendo de Sigmar



33
34
35
36
37
# File 'lib/buscar_tesoros.rb', line 33

def buscar_tesoros (tipo, sigmar, *doble) # DB in YAML format
  bt  = load_yaml('buscar_tesoros')[tipo]
  sig = doble ? sigmar + '2' : sigmar
  bt[sig] || bt['default']
end

#calcular_coste(p) ⇒ Object

Calcula el coste de un objeto


2
3
4
5
6
7
8
9
10
11
12
13
14
15
# File 'lib/calcular_coste.rb', line 2

def calcular_coste(p) # p = objeto a calcular
  # Inicializamos
  coste = 0
  eng = p[:engarces].split(',').sort.reverse
  eng.each_with_index do |e, i|
    # Coste de los engarces (joyas y runas = 4)
    valor_calibre = [5, 10, 25, 50, 100, 250, 500]
    # Avoid negative index values
    coste += valor_calibre[e.to_i - i] if (e.to_i - i) >= 0
  end
  # Reputacion
  coste *= 0.9**p[:repu].to_i # Factor de Repu
  coste.round # Redondea el coste sin decimales
end

#caras_sigmarObject

posibles 5 valores del dado sigmar


25
26
27
28
# File 'lib/buscar_tesoros.rb', line 25

def caras_sigmar
  # El sexto es eagle x2
  %w(eagle plus blank hammer comet)
end

#cofre(sigmar, _dado1, _dado2) ⇒ Object

12


99
100
101
102
103
# File 'lib/buscar_tesoros.rb', line 99

def cofre(sigmar, _dado1, _dado2) # 12
  r = %w(gema joya runa objeto artefacto)
  c = [gema_random, joya_random, runa_random, 'mágico', 'de reto']
  r[caras_sigmar.index(sigmar)] + ': ' + c[caras_sigmar.index(sigmar)]
end

#collect_values(hashes) ⇒ Object

Recoge los valores de las respuestas y los agrupa


7
8
9
# File 'lib/test.rb', line 7

def collect_values(hashes) # An array of hashes should be provided
  {}.tap { |r| hashes.each { |h| h.each { |k, v| (r[k] ||= []) << v } } }
end

#comida(sigmar, _dado1, _dado2) ⇒ Object

10


89
90
91
# File 'lib/buscar_tesoros.rb', line 89

def comida(sigmar, _dado1, _dado2) # 10
  buscar_tesoros('comida', sigmar)
end

#dado_sigmarObject

Tirada de dados, Sigmar


4
5
6
7
# File 'lib/buscar_tesoros.rb', line 4

def dado_sigmar
  # Returns a random dice-face string
  %w(hammer comet plus blank eagle eagle)[rand(6)]
end

#dado_tesoroObject

Tirada de dados, 2d6 del tesoro, individual


10
11
12
13
# File 'lib/buscar_tesoros.rb', line 10

def dado_tesoro
  # Returns a value from 1 to 6 (normal dice)
  rand(6) + 1
end

#familiares_conocidos(familiar_id) ⇒ Object


3
4
5
6
7
8
9
10
# File 'lib/indexators.rb', line 3

def familiares_conocidos(familiar_id)
  total = []
  heros.select(&:pet).each do |h|
    next unless h.pet.id == familiar_id
    total << h.id
  end
  total
end

#gema_randomObject

Genera una gema al azar


106
107
108
# File 'lib/buscar_tesoros.rb', line 106

def gema_random
  gemas.sample.name
end

#honor(jugador) ⇒ Object

Honor calculator, based on char lvl owned by player.


2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# File 'lib/honor.rb', line 2

def honor(jugador)
  honor = 0 # Initialize by 0

  heros.each do |h|
    # Increase honor for each player lvl
    honor += h.nivel if h.jugador == jugador
    # ONLY for MB players
    unless ciudad?(jugador).empty?
      # Increase honor for each MB player lvl/3
      honor += (h.nivel / 3).to_i if h.ciudad == ciudad?(jugador).first['name']
    end
  end

  honor
end

#joya_randomObject

Genera una joya al azar


111
112
113
# File 'lib/buscar_tesoros.rb', line 111

def joya_random
  joyas.sample.name
end

#load_yaml(path) ⇒ Object

Main fake DB loading method


5
6
7
8
9
10
# File 'lib/yaml_loader.rb', line 5

def load_yaml(path) # Path must be in /data
  # path must be a yaml file path
  YAML.load_file(File.join(__dir__, "../data/#{path}.yml"))
  # YAML keys will be allways strings (never symbols)
  # Returns hash of values (strings)
end

#maldición(sigmar, dado1, dado2) ⇒ Object

4


47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
# File 'lib/buscar_tesoros.rb', line 47

def maldición(sigmar, dado1, dado2) # 4
  doble = dado1 == dado2 # special condition
  case sigmar
  when 'eagle'  then
    "Maldición: #{doble ? 'Legañas: Tu siguiente tirada de ataque causará daños      a la miniatura más cercana' : 'Hirsutismo: -1 Reputación salvo enanos'} "
  when 'plus'   then
    "Maldición: #{doble ? 'Indispuesto: Tu siguiente hechizo o tirada de
     defensa fallará' : 'Alopecia: -1 Reputación si eres enano o mujer.'} "
  when 'blank'  then
    "Maldición: #{doble ? 'Patán: Tu siguiente tirada de tesoros tirará un dado
     menos' : 'Yuyu: En un momento dado, el MB puede hacer repetir 1d6.'} "
  when 'hammer' then
    "Maldición: #{doble ? 'Masoquismo: Golpéate sin armas con cada 1 que saques
    hasta el final del reto' : 'Alopecia: -1 Reputación si eres enano o
    mujer.'} "
  when 'comet'  then
    "Maldición: #{doble ? 'Mirado por un tuerto: El oro que obtengas en
     adelante, es falso.' : 'Infortunio: El MB podrá hacer repetir una tirada
     cualquiera.'} "
  end
end

#monstruo(sigmar, _dado1, _dado2) ⇒ Object

6


73
74
75
# File 'lib/buscar_tesoros.rb', line 73

def monstruo(sigmar, _dado1, _dado2) # 6
  buscar_tesoros('monstruo', sigmar)
end

#oro(sigmar, _dado1, _dado2) ⇒ Object

7


77
78
79
# File 'lib/buscar_tesoros.rb', line 77

def oro(sigmar, _dado1, _dado2) # 7
  buscar_tesoros('oro', sigmar)
end

#perg(sigmar, _dado1, _dado2) ⇒ Object

8


81
82
83
# File 'lib/buscar_tesoros.rb', line 81

def perg(sigmar, _dado1, _dado2) # 8
  buscar_tesoros('pergamino', sigmar)
end

#pifia(sigmar, _dado1, _dado2) ⇒ Object

2


39
40
41
# File 'lib/buscar_tesoros.rb', line 39

def pifia(sigmar, _dado1, _dado2) # 2
  buscar_tesoros('pifia', sigmar)
end

#pot(sigmar, _dado1, _dado2) ⇒ Object

9


85
86
87
# File 'lib/buscar_tesoros.rb', line 85

def pot(sigmar, _dado1, _dado2) # 9
  buscar_tesoros('poción', sigmar)
end

#preguntasObject

Dictionary for the character test (14 questions)


2
3
4
# File 'lib/test.rb', line 2

def preguntas
  load_yaml('personaje/test')
end

#quiensoy(codigo) ⇒ Object

/views/test/solucion.erb


24
25
26
27
28
# File 'lib/test.rb', line 24

def quiensoy(codigo)
  valores = collect_values(respuestas(codigo)) # agrupa por clave
  s = valores.each { |k, v| valores[k] = v.inject(:+) } # Suma los valores
  s.sort_by { |_key, value| -value }.to_h # Ordena por relevancia
end

#respuestas(codigo) ⇒ Object

After question num 14, this will turn on


12
13
14
15
16
17
18
19
20
21
# File 'lib/test.rb', line 12

def respuestas(codigo) # Code from URL
  if codigo.to_s.length == preguntas.count # Check size (14)
    preguntas.map do |p|
      r = codigo[p['id']].to_i # respuesta segun el codigo
      p['respuestas'][r].last  # valores de puntuacion segun codigo
    end                        # devuelve {"enano"=>2, "elfo"=>1} 14 veces
  else
    redirect :error # If not 14, then raise error
  end
end

#runa_randomObject

Genera una runa al azar


116
117
118
# File 'lib/buscar_tesoros.rb', line 116

def runa_random
  runas.sample.name
end

#tesoro(sigmar, dado1, dado2) ⇒ Object

Main method 2d6 + Sigmar dice


16
17
18
19
20
21
22
# File 'lib/buscar_tesoros.rb', line 16

def tesoro(sigmar, dado1, dado2)
  # 12 values (2d6) ordered
  valores = %w(pifia vacia maldición trampa monstruo oro
               perg pot comida alijo cofre)
  # Requests (send) a method, named equals to the values.
  send(valores[dado1 + dado2 - 2], sigmar, dado1, dado2)
end

#total_adivinanzasObject

This method takes number of files in path


2
3
4
5
# File 'lib/espadaroja.rb', line 2

def total_adivinanzas
  path = './views/items/espadaroja/adivinanzas/*'
  Dir[path].length
end

#trampa(sigmar, _dado1, _dado2) ⇒ Object

5


69
70
71
# File 'lib/buscar_tesoros.rb', line 69

def trampa(sigmar, _dado1, _dado2) # 5
  buscar_tesoros('trampa', sigmar)
end

#vacia(sigmar, _dado1, _dado2) ⇒ Object

3


43
44
45
# File 'lib/buscar_tesoros.rb', line 43

def vacia(sigmar, _dado1, _dado2) # 3
  buscar_tesoros('vacía', sigmar)
end