Package ch.sahits.game.openpatrician.engine.land.city

Class TavernEngine

java.lang.Object

ch.sahits.game.openpatrician.engine.AbstractEngine

ch.sahits.game.openpatrician.engine.land.city.TavernEngine

@Component
@Lazy
@DependentInitialisation(StartNewGameBean.class)
public class TavernEngine
extends AbstractEngine

Every city has a corresponding tavern engine. The guests in a tavern may change on a daily basis

Author:

Andi Hotz, (c) Sahits GmbH, 2013 Created on Jan 19, 2013

Field Summary

Fields

Modifier and Type	Field	Description
private AIPlayerList	aiPlayers
private AmountableProvider	amountableProvider
private CaptainEngine	captainEngine
private CityTavernRegistry	cities
private CitiesState	cityState
private MapService	cityUtils
private ComputablePriceV2	computablePrice
private Date	date
private static RandomNameLoader	firstNameLoader
private static RandomNameLoader	lastNameLoader
private IMap	map
private static RandomNameLoader	pirateFirstNameLoader
private static RandomNameLoader	pirateLastNameLoader
private SeaPiratesState	pirateState
private java.util.Random	rnd
private TavernProperties	tavernProperties
private com.google.common.eventbus.AsyncEventBus	timerEventBus

Constructor Summary

Constructors

Constructor	Description
TavernEngine()

Method Summary

Modifier and Type	Method	Description
void	addCity(TavernState state, ICity city)
private int	computeNumbersOfSailors(ICity city)
private void	fillDestinations(ICity city, ICity[] destinations)
java.util.List<AbstractEngine>	getChildren()	Any engine may hold various child engines.
void	handleDayChange(ClockTickDayChange event)
private void	handlePersonsBecomingAbsent(TavernState state)	Randomized state update for persons that are not present.
private void	handlePersonsBecomingPresent(ICity city, TavernState state)	Randomized state update for persons that are present.
private void	init()
private boolean	isAnnotatedType(ITavernPerson person, java.lang.Class annotation)
private void	unregister()
(package private) void	updateCityRelatedPersons(ITavernPerson person, ICity city)
(package private) void	updatePersons(ITavernPerson person)
private void	updateWareNeedOrSurplus(int val, IInformant informant)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

rnd

@Autowired
private java.util.Random rnd

captainEngine

@Autowired
private CaptainEngine captainEngine

timerEventBus

@Autowired
@Qualifier("timerEventBus")
private com.google.common.eventbus.AsyncEventBus timerEventBus

cities

@Autowired
private CityTavernRegistry cities

cityUtils

@Autowired
private MapService cityUtils

map

@Autowired
private IMap map

date

@Autowired
private Date date

pirateState

@Autowired
private SeaPiratesState pirateState

cityState

@Autowired
private CitiesState cityState

aiPlayers

@Autowired
private AIPlayerList aiPlayers

computablePrice

@Autowired
private ComputablePriceV2 computablePrice

amountableProvider

@Autowired
private AmountableProvider amountableProvider

tavernProperties

@Autowired
private TavernProperties tavernProperties

firstNameLoader

private static RandomNameLoader firstNameLoader

lastNameLoader

private static RandomNameLoader lastNameLoader

pirateFirstNameLoader

private static RandomNameLoader pirateFirstNameLoader

pirateLastNameLoader

private static RandomNameLoader pirateLastNameLoader

Constructor Detail

TavernEngine

public TavernEngine()

Method Detail

addCity

public void addCity(TavernState state,
                    ICity city)

getChildren

public java.util.List<AbstractEngine> getChildren()

Description copied from class: AbstractEngine

Any engine may hold various child engines. This is the way to retrieve them. If there are no child engines, return an empty list. Subclasses have to implement this in the proper way.

Specified by:

getChildren in class AbstractEngine

Returns:

list of child engines.

init

@PostConstruct
private void init()

unregister

@PreDestroy
private void unregister()

computeNumbersOfSailors

private int computeNumbersOfSailors(ICity city)

handleDayChange

public void handleDayChange(ClockTickDayChange event)

handlePersonsBecomingAbsent

private void handlePersonsBecomingAbsent(TavernState state)

Randomized state update for persons that are not present.

handlePersonsBecomingPresent

private void handlePersonsBecomingPresent(ICity city,
                                          TavernState state)

Randomized state update for persons that are present.

updatePersons

void updatePersons(ITavernPerson person)

updateWareNeedOrSurplus

private void updateWareNeedOrSurplus(int val,
                                     IInformant informant)

updateCityRelatedPersons

void updateCityRelatedPersons(ITavernPerson person,
                              ICity city)

fillDestinations

private void fillDestinations(ICity city,
                              ICity[] destinations)

isAnnotatedType

private boolean isAnnotatedType(ITavernPerson person,
                                java.lang.Class annotation)