public EffectsManager(IEffectsMgrClient effectsClient) {
_effectsClient = effectsClient;
_generalFactory = References.GeneralFactory;
_gameMgr = References.GameManager;
_myPoolMgr = References.MyPoolManager;
Subscribe();
}
public BallController(IBall spriteEntity, IGameManager gameManager):base(gameManager)
{
Ball = spriteEntity;
State = new StartBallState(this, gameManager, PlayerIndex.One);
View = new BallView(Ball, this );
GameScore = GameManager["GameScore"] as GameScore;
}
public GameTableViewModel(IGameManager gameManager)
{
if (gameManager == null) throw new ArgumentNullException("gameManager");
GameManager = gameManager;
InitializeGameCells(GameManager, GameManager.GameCells);
}
public ApplicationViewModel(IGameManager gameManager)
{
if (gameManager == null) throw new ArgumentNullException("gameManager");
GameManager = gameManager;
GameTableViewModel = new GameTableViewModel(gameManager);
}
public PadelEntityController(IPadel padel, IGameManager gameManager)
{
GameManager = gameManager;
Padel = padel;
View = new PadelView(padel, this);
}
public WCFHost(IBanManager banManager, IClientManager clientManager, IAdminManager adminManager, IGameManager gameManager)
{
BanManager = banManager;
ClientManager = clientManager;
AdminManager = adminManager;
GameManager = gameManager;
}
public PlayerScoredBallState(IBallController ballController, PlayerIndex playerIndex, IGameManager gameManager)
{
_ballController = ballController;
_playerIndex = playerIndex;
_gameManager = gameManager;
GameScore = gameManager["GameScore"] as GameScore;
}
public SettingsViewModel(IScreen screen, ISettingsManager settingsManager, IVersionManager versionManager, IGameManager gameManager)
{
HostScreen = screen;
_settingsManager = settingsManager;
_versionManager = versionManager;
_gameManager = gameManager;
ApiKey = _settingsManager.Settings.ApiKey;
AuthUser = _settingsManager.Settings.AuthUser;
AuthPass = _settingsManager.Settings.AuthPass;
Endpoint = _settingsManager.Settings.Endpoint;
PbxFolder = _settingsManager.Settings.PbxFolder;
SyncStarred = _settingsManager.Settings.SyncStarred;
DownloadOnStartup = _settingsManager.Settings.DownloadOnStartup;
PatchTableScripts = _settingsManager.Settings.PatchTableScripts;
MinimizeToTray = _settingsManager.Settings.MinimizeToTray;
ReformatXml = _settingsManager.Settings.ReformatXml;
XmlFileVP = _settingsManager.Settings.XmlFile[Platform.PlatformType.VP];
StartWithWindows = _settingsManager.Settings.StartWithWindows;
DownloadOrientation = _settingsManager.Settings.DownloadOrientation;
DownloadOrientationFallback = _settingsManager.Settings.DownloadOrientationFallback;
DownloadLighting = _settingsManager.Settings.DownloadLighting;
DownloadLightingFallback = _settingsManager.Settings.DownloadLightingFallback;
SaveSettings = ReactiveCommand.CreateAsyncTask(_ => Save());
SaveSettings.IsExecuting.ToProperty(this, vm => vm.IsValidating, out _isValidating);
SaveSettings.ThrownExceptions.Subscribe(e =>
{
// todo either remove or treat correctly.
Console.WriteLine("Exception while saving settings.");
});
ChooseFolder.Subscribe(_ => OpenFolderDialog());
CloseSettings.InvokeCommand(HostScreen.Router, r => r.NavigateBack);
_settingsManager.WhenAnyValue(sm => sm.Settings.IsFirstRun).ToProperty(this, vm => vm.IsFirstRun, out _isFirstRun);
_settingsManager.WhenAnyValue(sm => sm.CanCancel)
.CombineLatest(screen.Router.NavigationStack.Changed, (canCancel, _) => canCancel || screen.Router.NavigationStack.Count > 1)
.DistinctUntilChanged()
.StartWith(true)
.ToProperty(this, vm => vm.CanCancel, out _canCancel);
OrientationSettings.Add(new OrientationSetting("Portrait", SettingsManager.Orientation.Portrait));
OrientationSettings.Add(new OrientationSetting("Landscape", SettingsManager.Orientation.Landscape));
OrientationSettings.Add(new OrientationSetting("Universal (VP10)", SettingsManager.Orientation.Universal));
LightingSettings.Add(new LightingSetting("Day", SettingsManager.Lighting.Day));
LightingSettings.Add(new LightingSetting("Night", SettingsManager.Lighting.Night));
LightingSettings.Add(new LightingSetting("Universal (VP10)", SettingsManager.Lighting.Universal));
XmlFilesVP.Add("Visual Pinball");
XmlFilesVP.Add("Vpdb");
OrientationFallbackSettings.Add(new OrientationSetting("Same *", SettingsManager.Orientation.Same));
OrientationFallbackSettings.Add(new OrientationSetting("Portrait", SettingsManager.Orientation.Portrait));
OrientationFallbackSettings.Add(new OrientationSetting("Landscape", SettingsManager.Orientation.Landscape));
OrientationFallbackSettings.Add(new OrientationSetting("Any", SettingsManager.Orientation.Any));
LightingFallbackSettings.Add(new LightingSetting("Same *", SettingsManager.Lighting.Same));
LightingFallbackSettings.Add(new LightingSetting("Day", SettingsManager.Lighting.Day));
LightingFallbackSettings.Add(new LightingSetting("Night", SettingsManager.Lighting.Night));
LightingFallbackSettings.Add(new LightingSetting("Any", SettingsManager.Lighting.Any));
}
public DriftCorrector(Transform transform, Rigidbody rigidbody, string optionalClientName = "Unknown") {
D.Assert(!rigidbody.useGravity); // can be isKinematic until operations commence
ClientName = optionalClientName;
_transform = transform;
_rigidbody = rigidbody;
_gameMgr = References.GameManager;
_jobMgr = References.JobManager;
}
public virtual void Update(ISpriteEntity spriteEntity, GameTime gameTime, BallInput ballInput)
{
ballInput.PlayScored();
_gameManager = ((IGameManager)spriteEntity.Game.Services.GetService(typeof(IGameManager)));
int score = (int)_gameManager[PlayerScoreKey];
score++;
_gameManager[PlayerScoreKey] = score;
}
protected override void Initialize()
{
IOCContainer.Register(this);
_gameManager = GameFactory.GetGameManager();
_gameManager.Initialize(_graphics);
base.Initialize();
}
protected override void Awake() {
base.Awake();
_gameTime = GameTime.Instance;
_gameMgr = References.GameManager;
_rotationPeriod = GameTimeDuration.OneDay;
_rotationRate = _relativeRotationRate * Constants.DegreesPerRotation / (float)_rotationPeriod.TotalInHours;
Subscribe();
enabled = false;
}
public GamesImporterController(FantasyDataGamesImporter importer, IGameManager gameManager)
{
if (importer == null)
{
throw new ArgumentNullException("importer");
}
_importer = importer;
_gameManager = gameManager;
}
public FantasyDataGamesImporter(IGameManager gameManager, ITeamRepository teamRepository, IGameOptionRepository optionRepository)
{
_gameManager = gameManager;
_teamRepository = teamRepository;
_optionRepository = optionRepository;
_fantasyDataGames = new List<FantasyDataGame>();
_connectionString = ConfigurationManager.ConnectionStrings["sportpicksdb"].ConnectionString;
_season = Convert.ToInt32(ConfigurationManager.AppSettings["CurrentNflSeason"]);
_fantasyDataApiKey = ConfigurationManager.AppSettings["FantasyDataApiKey"];
_fantasyDataGamesUrl = ConfigurationManager.AppSettings["FantasyDataScoresUrl"];
}
public GameCellViewModel(GameTableViewModel gameTableViewModel, IGameManager gameManager, GameCell gameCell)
{
if (gameManager == null) throw new ArgumentNullException("gameManager");
if (gameCell == null) throw new ArgumentNullException("gameCell");
if (gameTableViewModel == null) throw new ArgumentNullException("gameTableViewModel");
GameTableViewModel = gameTableViewModel;
GameManager = gameManager;
GameCell = gameCell;
Symbol = GetSymbol(GameManager, GameCell);
InitializeCommands();
}
private String GetSymbol(IGameManager gameManager, GameCell gameCell)
{
if (gameCell.Owner == Player.NonPlayer)
{
return "";
}
if (gameCell.Owner == gameManager.Players.First())
{
return "X";
}
return "O";
}
/// <summary>
/// Constructs a new instance of <see cref="UnityServer"/> from "unity.config" file.
/// </summary>
public UnityServer()
{
var map = new ExeConfigurationFileMap {ExeConfigFilename = "unity.config"};
var config = ConfigurationManager.OpenMappedExeConfiguration(map, ConfigurationUserLevel.None);
UnityConfigurationSection section = (UnityConfigurationSection) config.GetSection("unity");
_container = new UnityContainer();
section.Configure(_container, "container");
_shotTracker = _container.Resolve<IShotTracker>();
_positionTracker = _container.Resolve<IPositionTracker>();
_playerManagement = _container.Resolve<IPlayerManagement>();
_signalStrengthTracker = _container.Resolve<ISignalStrengthTracker>();
_gameManager = _container.Resolve<IGameManager>();
ServerConsole = _container.Resolve<Console.Console>();
}
public async Task <MoveResult> Move(
MoveInput input,
[Service] IGameManager gameManager,
[Service] IEventSender eventSender,
CancellationToken cancellationToken
)
{
MoveResult result = await gameManager.Move(input.ToMove(), cancellationToken);
if (result.IsValid)
{
await eventSender.SendAsync(new OnMoveMessage(result.Move));
}
return(result);
}
public InGameMenuPresenter(
IInGameMenuView view,
IApplicationController controller,
IGameManager gameManager,
IApplicationService applicationService)
{
this.view = view;
this.controller = controller;
this.gameManager = gameManager;
this.applicationService = applicationService;
this.view.Exit += View_Exit;
this.view.ExitToMenu += View_ExitToMenu;
this.view.StartNewGame += View_StartNewGame;
this.view.ContinueGame += View_ContinueGame;
}
public WebSocketEndpoint(
GameManager gameManager,
ILogger logger,
IAppSettings settings,
ITokenProvider tokenProvider,
IGamePacketSerializer packetSerializer)
{
connection = new WSGameServerConnection(
logger,
settings,
tokenProvider,
packetSerializer);
connection.Register("game_event", new GameEventPacketHandler(gameManager));
this.gameManager = gameManager;
}
public override IEntity CreateEntity(IGameManager gameManager, Vector2 position)
{
IEntity entity = InstantiatePrefab(Prefab, gameManager, position);
if (entity is IMicro micro)
{
micro.UpdateProvider = MicroUpdateProvider;
ClosestProximityController closestProximityController =
new ClosestProximityController(ControllerUpdateProvider);
closestProximityController.Controllable = micro;
micro.Controller = closestProximityController;
micro.BreedingFactory = this;
}
return(entity);
}
public SessionController(
ILogger <SessionController> logger,
IGameData gameData,
ISessionInfoProvider sessionInfoProvider,
IAuthManager authManager,
ISessionManager sessionManager,
IGameManager gameManager,
ISecureHasher secureHasher)
: base(logger, gameData, authManager, sessionInfoProvider, sessionManager, secureHasher)
{
this.gameData = gameData;
this.authManager = authManager;
this.sessionManager = sessionManager;
this.gameManager = gameManager;
this.secureHasher = secureHasher;
}
public GameManagers(IGameManager gameManager, IActivateCardManager activateCardManager, IBarsPlayerManager barsPlayerManager,
IBarsEnemyManager barsEnemyManager, IEnemyManager enemyManager, IAlliesManager alliesManager, IPlayersManager playersManager, IDeckManager deckManager,
IInventoryManager inventoryManager, ITargetManager targetManager, ITokenRewardManager tokenRewardManager)
{
GameManager = gameManager;
ActivateCardManager = activateCardManager;
BarsPlayerManager = barsPlayerManager;
BarsEnemyManager = barsEnemyManager;
EnemyManager = enemyManager;
AlliesManager = alliesManager;
PlayersManager = playersManager;
DeckManager = deckManager;
InventoryManager = inventoryManager;
TargetManager = targetManager;
TokenRewardManager = tokenRewardManager;
}
public void SetUp()
{
ActionLog actionLog = new ActionLog();
GlobalConstants.ActionLog = actionLog;
this.scriptingEngine = new ScriptingEngine();
this.target = new ConcreteRumourMill();
IWorldInstance world = Mock.Of <IWorldInstance>();
IGameManager gameManager = Mock.Of <IGameManager>(
manager => manager.NeedHandler == Mock.Of <INeedHandler>(
handler => handler.GetManyRandomised(It.IsAny <IEnumerable <string> >())
== new List <INeed>()) &&
manager.SkillHandler == Mock.Of <IEntitySkillHandler>(
handler => handler.GetDefaultSkillBlock()
== new Dictionary <string, IEntitySkill>
{
{
"light blades",
new EntitySkill(
"light blades",
5,
7)
}
}) &&
manager.RelationshipHandler == Mock.Of <IEntityRelationshipHandler>() &&
manager.ObjectIconHandler == Mock.Of <IObjectIconHandler>());
GlobalConstants.GameManager = gameManager;
IGender gender = Mock.Of <IGender>(
g => g.PersonalSubject == "her");
IDictionary <string, IEntitySkill> skills = gameManager.SkillHandler.GetDefaultSkillBlock();
this.left = Mock.Of <IEntity>(
entity => entity.PlayerControlled == true &&
entity.JoyName == "TEST1" &&
entity.Skills == skills);
this.right = Mock.Of <IEntity>(
entity => entity.JoyName == "TEST2" &&
entity.Skills == skills);
}
public void StartUpSettingsFileLoaded()
{
//Проверяем, что ссылка на скриптовый объект с настройками привязался
var settings = Container.Resolve <GameSettings>();
Assert.NotNull(settings);
//Записываем туда пустые данные
settings.SetData(new Data());
//Грузим настройки через менеджер
IGameManager manager = Container.Resolve <IGameManager>();
manager.LoadStartUpSettingsFile(GameConst.StartUpSettingsFile);
Assert.Greater(settings.Data.stats.Length, 0);
}
public GameController(IGameManager gameManager,
ChangeSceneSignal changeSceneSignal,
GameStatusChangedSignal gameStatusChangedSignal,
AreaClickedSignal areaClickedSignal,
CurrentMarkChangedSignal currentMarkChangedSignal,
ResetSignal resetSignal,
RestartSignal restartSignal
)
{
_gameManager = gameManager;
_changeSceneSignal = changeSceneSignal;
_areaClickedSignal = areaClickedSignal;
_gameStatusChangedSignal = gameStatusChangedSignal;
_currentMarkChangedSignal = currentMarkChangedSignal;
_resetSignal = resetSignal;
_restartSignal = restartSignal;
}
public WebSocketConnectionProvider(
ILogger <WebSocketConnectionProvider> logger,
IIntegrityChecker integrityChecker,
IGameData gameData,
IGameManager gameManager,
IGamePacketManager packetManager,
IGamePacketSerializer packetSerializer,
ISessionManager sessionManager)
{
this.logger = logger;
this.integrityChecker = integrityChecker;
this.gameData = gameData;
this.gameManager = gameManager;
this.packetManager = packetManager;
this.packetSerializer = packetSerializer;
this.sessionManager = sessionManager;
}
private void AddManager(string[] typeNames, bool constant)
{
GameObject go = constant ? _constManagerLayer : _dynamicManagerLayer;
List <IGameManager> managerPool = constant ? _constManagers : _dynamicManagers;
Type managerBaseType = typeof(IGameManager);
for (int i = 0; i < typeNames.Length; i++)
{
string name = typeNames[i];
Type type = Type.GetType(name);
if (type != null)
{
if (managerBaseType.IsAssignableFrom(type))
{
if (type.IsSubclassOf(typeof(MonoBehaviour)))
{
GameObject node = new GameObject(type.Name);
node.transform.parent = go.transform;
managerPool.Add(node.AddComponent(type) as IGameManager);
}
else
{
IGameManager mgr = GameManageHelper.GetCustomManage(type);
if (mgr != null)
{
managerPool.Add(mgr);
}
}
}
else
{
string msg = string.Format("type is not inherit form IGameManager: {0}", name);
Error(msg);
throw new Exception(msg);
}
}
else
{
string msg = string.Format("type is not found: {0}", name);
Error(msg);
throw new Exception(msg);
}
}
}
public override void Spawn(IGameManager gameManager)
{
base.Spawn(gameManager);
var snakeLength = _gameManager.Settings.SnakeStartLength;
while (true)
{
var startCell = _gameManager.GetRandomEmptyCell();
var fit = true;
for (var dX = 1; dX < snakeLength; dX++)
{
if (startCell.X + dX >= _gameManager.Settings.GameFieldSize ||
_gameManager.GetGameFieldCellEntities(startCell.X + dX, startCell.Y, startCell.Z).Count != 0)
{
fit = false;
break;
}
}
if (fit)
{
for (var dX = 0; dX < snakeLength; dX++)
{
var cell = new GameFieldCell
{
X = startCell.X + dX,
Y = startCell.Y,
Z = startCell.Z
};
_gameManager.AssignGameEntityToGameFieldCell(this, cell);
var snakePart = Instantiate(_gameManager.Settings.SnakePartPrefab,
_gameManager.GameCellToWorldCoords(cell),
Quaternion.identity,
transform);
_snakeParts.Add(snakePart.transform);
_cells.Add(cell);
}
break;
}
}
}
private void Start()
{
gameManager = interfaceFactory.GameManager;
errorHandler = interfaceFactory.ErrorHandler;
uiManager = interfaceFactory.UIManager;
if (gameManager == null || errorHandler == null || uiManager == null)
{
gameObject.SetActive(false);
}
else
{
if (componentMissing)
{
errorHandler.ReportError("Tourist Manager component missing", ErrorState.restart_scene);
}
inventoryUI = uiManager.InventoryUI;
if (inventoryUI == null)
{
errorHandler.ReportError("Inventory UI missing", ErrorState.restart_scene);
}
turnsManager = gameManager.TurnsManager;
if (turnsManager == null)
{
errorHandler.ReportError("Turns Manager missing", ErrorState.restart_scene);
}
else
{
if (turnsManager.TurnBasedObjects == null)
{
errorHandler.ReportError("Turn based objects list not initialized", ErrorState.restart_scene);
}
else
{
turnsManager.TurnBasedObjects.Add(this);
}
}
playerManager = gameManager.PlayerManager;
if (playerManager == null)
{
errorHandler.ReportError("Player Manager missing", ErrorState.restart_scene);
}
}
}
public LettersHub(IWordService wordService, IFileHelper fileHelper, IFilenameHelper filenameHelper, IJoinRoomHelper joinRoomHelper, IGameManager gameManager)
{
_wordService = wordService;
_fileHelper = fileHelper;
_filenameHelper = filenameHelper;
_joinRoomHelper = joinRoomHelper;
_gameManager = gameManager;
if (!File.Exists(_filenameHelper.GetDictionaryFilename()))
{
File.Create(_filenameHelper.GetDictionaryFilename());
}
if (!File.Exists(_filenameHelper.GetGuessedWordsFilename()))
{
File.Create(_filenameHelper.GetGuessedWordsFilename());
}
}
public DiceManager(IGameManager gameManager, StringBuilder log)
{
Log = log;
GameManager = gameManager;
DiceList = new List <Dice>();
DiceCreator = new DiceCreator();
Dice newDice;
int chipsCount = GameManager.CurrentPlayer.Chips > 3 ? 3 : GameManager.CurrentPlayer.Chips;
for (int diceId = 1; diceId <= chipsCount; diceId++)
{
newDice = DiceCreator.CreateDice(diceId);
DiceList.Add(newDice);
}
ChipsManager = new ChipsManager(GameManager, DiceList);
}
/// <summary>
/// initialized by the Game manager with the required dependencies
/// </summary>
public void Init(IGameManager gameManager, IInput input)
{
_gameManager = gameManager;
//Event registrations
_gameManager.LevelInitiazed += OnLevelInitialized;
_gameManager.LevelStarted += OnLevelStarted;
_gameManager.TowerLevelChanged += OnTowerLevelChanged;
_gameManager.GameplayStarted += OnGamePlayStarted;
_gameManager.LevelCompleted += OnLevelFinished;
_gameManager.GameOver += OnLevelFinished;
_gameManager.BlockReduced += OnBlockReduced;
//Object creations. passing dependencies and event callbacks
_tower = new Tower(ObjectPooler.Instance, _gameManager.RaiseTowerLevelChangedEvent, _gameManager.RaiseBlockReducedEvent);
_scoreManger = new ScoreManager(_gameManager.RaiseScoredEvent, _gameManager.RaiseLevelCompletedEvent);
_ballManager = new BallManager(input, _camera, _ballSettings, _gameManager.RaiseGameOverEvent);
}
/// <summary>
/// 状态结束
/// </summary>
/// <param name="currStateName"></param>
/// <param name="nextStateName"></param>
public void OnEndStateExit(string currStateName, string nextStateName)
{
_loadLevelExceptionCount = 0;
for (int i = 0; i < _constManagers.Count; i++)
{
IGameManager mamager = _constManagers[i];
try
{
mamager.OnEndStateExit(currStateName, nextStateName);
}
catch (Exception e)
{
ShowExceptionPopup(e, _evtOnExceptionPopupConfirm, mamager.GetType().Name);
}
}
DestroyDynamicManager();
Facade.Instance.ClearAll();
}
// Execute some logic when the game scene has loaded
public override void OnGameLoad(IGameManager gameManager)
{
// Register an item sprite from our asset bundle, so the game knows how to render it
gameManager.GetItemManager().RegisterAsset(this, CandyBarItem.ID, "assets/candy-bar.png");
// Loop through all players
foreach (IPlayer player in gameManager.GetPlayers())
{
var playerInventory = player.GetInventory();
// Ensure they don't have a candy bar already
if (!playerInventory.Has(CandyBarItem.ID))
{
// Give them a candy bar
playerInventory.Add(new CandyBarItem());
}
}
}
public NflDotComGamesImporter(IGameManager gameManager, ITeamRepository teamRepository)
{
if (gameManager == null)
{
throw new ArgumentNullException("gameRepository");
}
if (teamRepository == null)
{
throw new ArgumentNullException("teamRepository");
}
_gameManager = gameManager;
_teamRepository = teamRepository;
_games = new List<Game>();
_nflDotComGames = new List<NflDotComGame>();
_connectionString = ConfigurationManager.ConnectionStrings["sportpicksdb"].ConnectionString;
}
public GameRunner(Server server,
IGameSettingsCore <AppSettingsCore> settings,
SIDocument document,
IGameManager backLink,
IShare share,
ComputerAccount[] defaultPlayers,
ComputerAccount[] defaultShowmans,
bool createHost = true)
{
_server = server;
_settings = settings;
_document = document;
_backLink = backLink;
_share = share;
_defaultPlayers = defaultPlayers;
_defaultShowmans = defaultShowmans;
_createHost = createHost;
}
private void Start()
{
globeManager = interfaceFactory.GlobeManager;
errorHandler = interfaceFactory.ErrorHandler;
gameManager = interfaceFactory.GameManager;
if (globeManager == null || errorHandler == null || gameManager == null)
{
gameObject.SetActive(false);
}
else
{
worldMapGlobe = globeManager.WorldMapGlobe;
if (worldMapGlobe == null)
{
errorHandler.ReportError("World Map Globe missing", ErrorState.restart_scene);
}
}
}
void Start()
{
gameManager = interfaceFactory.GameManager;
globeManager = interfaceFactory.GlobeManager;
errorHandler = interfaceFactory.ErrorHandler;
if (gameManager == null || globeManager == null || errorHandler == null)
{
gameObject.SetActive(false);
}
else
{
cellCursorInterface = globeManager.CellCursorInterface;
if (cellCursorInterface == null)
{
errorHandler.ReportError("CellCurserInterface no found", ErrorState.restart_scene);
}
}
}
public void Init()
{
_uiManager = GameClient.Get <IUIManager>();
_loadObjectsManager = GameClient.Get <ILoadObjectsManager>();
_gameManager = GameClient.Get <IGameManager>();
_selfPopup = MonoBehaviour.Instantiate(_loadObjectsManager.GetObjectByPath <GameObject>(Constants.PATH_TO_UI_PREFABS + "Popups/TowerPopup"));
_selfPopup.transform.SetParent(_uiManager.PopupsContainer.transform, false);
_container = _selfPopup.transform.Find("Container").GetComponent <RectTransform>();
_sellTowerButton = _container.Find("Button_SellTower").GetComponent <Button>();
_sellTowerButton.onClick.AddListener(OnSellTowerButtonClickHandler);
_sellTowerButtonLabelText = _sellTowerButton.transform.Find("Text_Label").GetComponent <TextMeshProUGUI>();
Hide();
}
public static void Main(string[] args)
{
try
{
/*
* Uncomment the following lines to run this project in debug more with following files.
*/
//args = new string[2];
//args[0] = "game-settings.xml";
//args[1] = "moves.xml";
log4net.Config.XmlConfigurator.Configure();
Logger.InfoFormat("------------------------------------");
Logger.InfoFormat("Turtle challenge game launched.");
Logger.InfoFormat("------------------------------------");
TurtleChallengeIoCConfigurator.ConfigureIoC();
IGameManager manager = IoCContainer.Instance().Resolve <IGameManager>();
string gameSettingsFile = args[0]; // assuming the user inputs the game settings file with its extension being xml or json..
string movesFile = args[1]; // assuming the user inputs the moves file with its extension being xml or json.
Logger.InfoFormat($"Starting the game with {gameSettingsFile} and {movesFile} files.");
IEnumerable <string> sequenceResults = manager.Start(gameSettingsFile, movesFile);
foreach (string sequenceResult in sequenceResults)
{
Console.WriteLine(sequenceResult);
Logger.InfoFormat(sequenceResult);
}
Logger.InfoFormat("------------------------------------");
Logger.InfoFormat("Turtle challenge game exits.");
Logger.InfoFormat("------------------------------------");
}
catch (Exception ex)
{
Console.WriteLine("A fatel error occured during the execution of the game. Please check the log file for the detailed error message.\n");
Logger.ErrorFormat($"A fatel error occured during the execution of the game. Details {ex}");
}
}
public void Setup()
{
_hallOfFameRepository = A.Fake <IHallOfFameRepository>();
_gameManager = new GameManager(_hallOfFameRepository);
_gameSetup = new GameSetup()
{
BannedCards = new List <CardValue>()
};
_game = new Game(_gameSetup);
_game.Direction = Direction.Left;
_game.Deck = new Deck(_gameSetup);
_game.DiscardedPile = new List <ICard>()
{
new Charity(), new BlackHole(), new Blackjack()
};
_game.LastCardPlayed = new LastCardPlayed(CardColor.Blue, CardValue.Five, "", "", false);
var player = new Player(new User("123", "john"));
var player2 = new Player(new User("456", "andrew"));
player.Cards = new List <ICard>()
{
new Charity(), new BlackHole(), new Blackjack(), new Charity(), new BlackHole(), new Blackjack()
};
player2.Cards = new List <ICard>()
{
new Charity(), new BlackHole(), new Blackjack(), new Charity(), new BlackHole(), new Blackjack()
};
_game.Players = new List <Player>()
{
player, player2
};
_game.PlayerToPlay = player;
_moveParams = new MoveParams(player, player.Cards.First(), player, CardColor.Blue, _game.DiscardedPile.First(), new List <int>()
{
1, 2, 3
}, new List <ICard>()
{
new Charity()
}, 10, new List <int>()
{
0, 1
}, new BlackHole(), "odd");
}
public MainMenuPresenter(
IMainMenuView view,
IApplicationController controller,
IApplicationService applicationService,
IGameManager gameManager)
{
this.view = view;
this.controller = controller;
this.applicationService = applicationService;
this.gameManager = gameManager;
this.view.SetContinueOptionState(CurrentGame.Game != null);
this.view.StartGame += View_StartGame;
this.view.ContinueGame += View_ContinueGame;
this.view.ShowSpellLibrary += View_ShowSpellLibrary;
this.view.ShowSettings += View_ShowSettings;
this.view.Exit += View_Exit;
}
public ShellViewModel(IGameManager gameManager,
IDialogService dialogService,
IEventAggregator eventAggregator,
IPackageManager packageManager,
IApplicationCommands applicationCommands
)
{
PlayCommand = new DelegateCommand(OpenPlaywindow);
SelectSavefilePathCommand = new DelegateCommand(SelectSavefilePath);
SaveCommand = new DelegateCommand(SaveData);
LoadCommand = new DelegateCommand(LoadData);
PublishCommand = new DelegateCommand(PublishPackage);
ApplicationCommands = applicationCommands;
_gameManager = gameManager;
_dialogService = dialogService;
_eventAggregator = eventAggregator;
_packageManager = packageManager;
}
public override void _Ready()
{
this.Parts = new List <StringValueItem>();
this.ListItemPrefab = GD.Load <PackedScene>(
GlobalConstants.GODOT_ASSETS_FOLDER +
"Scenes/Parts/String List Item.tscn");
IGameManager gameManager = GlobalConstants.GameManager;
this.EntityTemplateHandler = gameManager.EntityTemplateHandler;
this.CultureHandler = gameManager.CultureHandler;
this.GenderHandler = gameManager.GenderHandler;
this.BioSexHandler = gameManager.BioSexHandler;
this.SexualityHandler = gameManager.SexualityHandler;
this.RomanceHandler = gameManager.RomanceHandler;
this.JobHandler = gameManager.JobHandler;
this.SetUp();
}
void IInputEvent.ButtonEvent(int input, IGameManager igameManager)
{
if (input == 0)
{
switch (cursor.select)
{
case 0:
SetBattleMenuEnable(false);
nextMenu = new StatusMenu(this);
nextMenu.CreateCanvas(dataManager);
break;
case 1:
SetBattleMenuEnable(false);
nextMenu = new ImageMenu(this, "Other/manual_attack");
nextMenu.CreateCanvas(dataManager);
break;
case 2:
SetBattleMenuEnable(false);
nextMenu = new ImageMenu(this, "Other/manual");
nextMenu.CreateCanvas(dataManager);
break;
case 3:
nextMenu = null;
MonoBehaviour.Destroy(canvas.gameObject);
igameManager.SetEnemyUnitsEnable(true);
break;
case 4:
nextMenu = new WindowMenu(this, "return_title");
nextMenu.CreateCanvas(dataManager);
break;
}
}
else if (input == 1)
{
nextMenu = null;
MonoBehaviour.Destroy(canvas.gameObject);
igameManager.SetEnemyUnitsEnable(true);
}
}
public LabirynthGame(Game game)
{
keys = new List <Key>();
basicEffect = new BasicEffect(game.GraphicsDevice)
{
TextureEnabled = true,
World = Matrix.Identity,
PreferPerPixelLighting = true
};
basicEffect.EnableDefaultLighting();
basicEffect.DirectionalLight0.Enabled = true;
basicEffect.DirectionalLight0.SpecularColor = new Vector3(0, 0, 0);
basicEffect.DirectionalLight1.Enabled = true;
basicEffect.DirectionalLight2.Enabled = true;
//basicEffect.AmbientLightColor = new Vector3(0.2f, 0.2f, 0.2f);
//basicEffect.EmissiveColor = new Vector3(1, 0, 0);
AssetHolder.Instance.GandalfMusicInstance.IsLooped = true;
AssetHolder.Instance.KeyPickupfMusicInstance.IsLooped = false;
this.game = game;
gameManager = (IGameManager)game.Services.GetService(typeof(IGameManager));
screenManager = (IScreenManager)game.Services.GetService(typeof(IScreenManager));
controlManager = (IControlManager)game.Services.GetService(typeof(IControlManager));
labirynth = new LabirynthCreator(game);
player = new Player(new Vector3(), 2.0f, game);
finish = new Vector3();
if (gameManager.Type == LabiryntType.Recursive)
{
CollisionChecker.Instance.Walls = labirynth.ModelMap;
}
else if (gameManager.Type == LabiryntType.Prim)
{
CollisionChecker.Instance.VertexWalls = labirynth.VertexMap;
}
skyBox = new SkyBox(new Vector3((float)DifficultyLevel.Hard / 2, (float)DifficultyLevel.Hard / 2, 0), new Vector3(90, 0, 0), new Vector3(5f));
finishPoint = new Finish(finish, game.GraphicsDevice, game);
keys = labirynth.GetKeys(gameManager.Type, game.GraphicsDevice, game);
ground = new Ground(game, labirynth.GroundMap);
minimap = new Minimap(labirynth.getMap(gameManager.Type), game, screenManager);
}
public WebSocketConnection(
ILogger logger,
IGameManager gameManager,
IGamePacketManager packetManager,
IGamePacketSerializer packetSerializer,
WebSocketConnectionProvider sessionProvider,
WebSocket ws,
SessionToken sessionToken)
{
this.receiveLoop = new Thread(ReceiveLoop);
this.gameLoop = new Thread(GameUpdateLoop);
this.logger = logger;
this.gameManager = gameManager;
this.packetManager = packetManager;
this.packetSerializer = packetSerializer;
this.sessionProvider = sessionProvider;
this.sessionToken = sessionToken;
this.ws = ws;
this.killTask = new TaskCompletionSource <object>();
}
protected InputControllerBase(IGameManager gameManager, PlayerIndex playerIndex) : base(gameManager)
{
PlayerIndex = playerIndex;
}
public GamesController(IGameManager manager)
{
_manager = manager;
}
public SettingsViewModel(IScreen screen, ISettingsManager settingsManager, IVersionManager versionManager, IGameManager gameManager, Dictionary<string, string> errors) : this(screen, settingsManager, versionManager, gameManager)
{
Errors = errors;
}
public GameItemViewModel(Game game, IDependencyResolver resolver)
{
Game = game;
_logger = resolver.GetService<ILogger>();
_vpdbClient = resolver.GetService<IVpdbClient>();
_gameManager = resolver.GetService<IGameManager>();
_messageManager = resolver.GetService<IMessageManager>();
var threadManager = resolver.GetService<IThreadManager>();
// release identify
IdentifyRelease = ReactiveCommand.CreateAsyncObservable(_ => _vpdbClient.Api.GetReleasesBySize(Game.FileSize, MatchThreshold).SubscribeOn(threadManager.WorkerScheduler));
IdentifyRelease.Select(releases => releases
.Select(release => new {release, release.Versions})
.SelectMany(x => x.Versions.Select(version => new {x.release, version, version.Files}))
.SelectMany(x => x.Files.Select(file => new GameResultItemViewModel(game, x.release, x.version, file, CloseResults)))
).Subscribe(x => {
var releases = x as GameResultItemViewModel[] ?? x.ToArray();
var numMatches = 0;
_logger.Info("Found {0} releases for game to identify.", releases.Length);
GameResultItemViewModel match = null;
foreach (var vm in releases) {
if (game.Filename == vm.TableFile.Reference.Name && game.FileSize == vm.TableFile.Reference.Bytes) {
numMatches++;
match = vm;
}
}
_logger.Info("Found {0} identical match(es).", numMatches);
// if file name and file size are identical, directly match.
if (numMatches == 1 && match != null) {
_logger.Info("File name and size are equal to local release, linking.");
_gameManager.LinkRelease(match.Game, match.Release, match.TableFile.Reference.Id);
_messageManager.LogReleaseLinked(match.Game, match.Release, match.TableFile.Reference.Id);
} else {
_logger.Info("View model updated with identified releases.");
IdentifiedReleases = releases;
HasExecuted = true;
}
}, exception => _vpdbClient.HandleApiError(exception, "identifying a game by file size"));
//SyncToggled
// .Where(_ => Game.IsSynced && Game.HasRelease)
// .Subscribe(_ => { GameManager.Sync(Game); });
// handle errors
IdentifyRelease.ThrownExceptions.Subscribe(e => { _logger.Error(e, "Error matching game."); });
// spinner
IdentifyRelease.IsExecuting.ToProperty(this, vm => vm.IsExecuting, out _isExecuting);
// result switch
IdentifyRelease.Select(r => r.Count > 0).Subscribe(hasResults => { HasResults = hasResults; });
// close button
CloseResults.Subscribe(_ => { HasExecuted = false; });
// identify button visibility
this.WhenAny(
vm => vm.HasExecuted,
vm => vm.Game.HasRelease,
vm => vm.IsExecuting,
(hasExecuted, hasRelease, isExecuting) => !hasExecuted.Value && !hasRelease.Value && !isExecuting.Value
).ToProperty(this, vm => vm.ShowIdentifyButton, out _showIdentifyButton);
}
public BallController(IBall spriteEntity, IBallState ballState, IGameManager gameManager)
{
Ball = spriteEntity;
State = ballState;
GameManager = gameManager;
}
protected TextEntityControllerBase(ITextEntity textEntity, IGameManager gameManager)
{
Model = textEntity;
_gameManager = gameManager;
}
public GameHub(IGameManager gameManager, IDiscColorManager discColorManager)
{
_discColorManager = discColorManager;
_gameManager = gameManager;
}
protected PadelInputController(IPadelController controller, IGameManager gameManager, PlayerIndex playerIndex)
: base(gameManager, playerIndex)
{
PadelController = controller;
}
protected SpriteEntityControllerBase(IGameManager gameManager)
{
_gameManager = gameManager;
}
public override void RemoveFromGameManager(IGameManager gameManager)
{
gameManager.ReleaseAspectList<LabelAspect>();
OnRemovedFromGameManager();
}
public override void AddToGameManager(IGameManager gameManager)
{
_labelAspects = gameManager.GetAspectList<LabelAspect>();
OnAddedToGameManager(gameManager);
}
public GameManagerProxy(IGameManager gameManager)
{
_gameManager = gameManager;
}
