public async Task <IActionResult> Edit(int id, [Bind("CreatorId,CreatorName,Description")] GameCreator gameCreator)
{
if (id != gameCreator.CreatorId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(gameCreator);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!GameCreatorExists(gameCreator.CreatorId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(gameCreator));
}
private void Start()
{
uIHandler = FindObjectOfType(typeof(UIHandler)) as UIHandler;
gameCreator = FindObjectOfType(typeof(GameCreator)) as GameCreator;
hexList = gameCreator.hexPositions;
sizeOfOverlapBox = new Vector2(0.3f, 0.3f);
}
// Start is called before the first frame update
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
if (GUILayout.Button("Select Folder"))
{
string path = AssetsRelativePath(EditorUtility.OpenFolderPanel("Select Genome Folder", "", ""));
if (path.Length != 0)
{
List <TextAsset> xmlFiles = new List <TextAsset>();
var assets = AssetDatabase.FindAssets("t:TextAsset", new[] { path });
foreach (var asset in assets)
{
if (!AssetDatabase.GUIDToAssetPath(asset).EndsWith("bytes"))
{
continue;
}
xmlFiles.Add(AssetDatabase.LoadAssetAtPath <TextAsset>(AssetDatabase.GUIDToAssetPath(asset)));
}
((LoadGenomeManager)serializedObject.targetObject).genomesToLoad = xmlFiles.ToArray();
GameCreator creator = FindObjectOfType <GameCreator>();
creator.gamesToShow = 4;
creator.gamesToCreate = xmlFiles.Count;
creator.inspectionMode = true;
serializedObject.Update();
EditorUtility.SetDirty(creator);
}
}
}
// Start is called before the first frame update
void Awake()
{
creator = FindObjectOfType <GameCreator>();
creator.focusGameIndexOverride = FocusGame;
creator.focusNextOverride = NextGame;
creator.focusPrevOverride = PrevGame;
creator.OnNewGeneration.AddListener(NewGen);
}
public SocketMessage StartGame(Chanel chanel, object data, string userName)
{
var gameZone = GameCreator.StartGame();
Console.WriteLine($"{userName} Started game");
return(new SocketMessage(ClientFunctionsNames.SetGameZone.ToString(), gameZone));
}
protected override Vector3 NextPoint()
{
Vector3 next = GameCreator.randomPosOnMap(groundOffset);
next.x += Random.Range(-range, range);
isWaitingForNewPoint = false;
return(next);
}
public SocketMessage ContinueGame(Chanel chanel, object data, string userName)
{
int level = (int)data;
var gameZone = GameCreator.GenerateZone(level);
Console.WriteLine($"{userName} on {level} level ");
return(new SocketMessage(ClientFunctionsNames.SetGameZone.ToString(), gameZone));
}
private void Start()
{
gameCreator = GameObject.Find("Config").GetComponent <GameCreator>();
configScriptable = gameCreator.configScriptable;
_rigidbody = GetComponent <Rigidbody>();
hpBar = GameObject.Find("HPBar").GetComponent <Image>();
isDead = false;
BrainInitialisation();
}
public void should_CreateAGame_When_Invoked(string bowlingString, int frameCount, int gamesScore)
{
var gameCreator =
new GameCreator(new BowlingFramesCreator(new BowlingStringSplitter(),
new BowlingFrameCreator(new BowlScorer()), new BonusScorer()));
var game = gameCreator.Create(bowlingString);
Assert.That(game.Frames.Count, Is.EqualTo(frameCount));
Assert.That(game.Score(), Is.EqualTo(gamesScore));
}
new void Start()
{
int nbPointInPath = Random.Range(3, 5);
path = new List <Vector3>();
for (int i = 0; i < nbPointInPath; i++)
{
path.Add(GameCreator.randomPosOnMap(groundOffset));
}
base.Start();
}
public async Task <IActionResult> Create([Bind("CreatorId,CreatorName,Description")] GameCreator gameCreator)
{
if (ModelState.IsValid)
{
_context.Add(gameCreator);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(gameCreator));
}
public void AIGameFactoryMethodTest()
{
// arrange
var gameCreator = new GameCreator(new ConfigProvider(new ConfigurationBuilder().Build()), new Display(new ConfigProvider(new ConfigurationBuilder().Build())), new SnakeBot(new SnakeAIModel(), new ModelInputHelper()));
// act
var actual = gameCreator.AIGameFactoryMethod();
// assert
Assert.IsInstanceOf <AIGame>(actual);
}
public void SetUp()
{
_dic = File.ReadAllLines("e:\\enable1.txt").ToList();
// Using mock framework Moq
_picker = new Mock<IPickAChoice<int>>();
_picker.Setup(x => x.Pick(It.IsAny<List<int>>())).Returns(5);
// Creates the mock of IPickAChoice and fixes the return of Pick to 5,
// if any list of integers is provided as an argument.
_gameCreator = new GameCreator("easy", _dic, _picker.Object);
}
static void Main(string[] args)
{
GameCreator gameCreator = new GameCreator();
Manipulator manipulator = Manipulator.GetInstance();
CommandHistory commandHistory = new CommandHistory();
CommandManager commandManager = new CommandManager(gameCreator, manipulator, commandHistory);
GameMessageHolder messageHolder = new GameMessageHolder();
ConsoleManager consoleManager = new ConsoleManager();
IController controller = new Controller(gameCreator, manipulator, commandHistory, commandManager,
messageHolder, consoleManager);
controller.ServeGame();
}
// Start is called before the first frame update
void Awake()
{
memoryStore = FindObjectOfType <ReplayMemoryStore>();
creator = FindObjectOfType <GameCreator>();
creator.focusGameIndexOverride = FocusGame;
creator.focusNextOverride = NextGame;
creator.focusPrevOverride = PrevGame;
//foreach(string path in replays)
//{
// Debug.Log("Loaded Replay: " + path);
//}
}
private void LunchGame(object sender, RoutedEventArgs e)
{
if (RacePlayer1.Text == RacePlayer2.Text)
{
MessageBoxResult msg = MessageBox.Show("Players must have different races");
return;
}
GameCreator gc = new GameCreator();
gc.setPeopleJ1(RacePlayer1.Text);
gc.setPeopleJ2(RacePlayer2.Text);
GameBuilder gb;
switch (TypeOfGame.Text)
{
case "Demo Game":
gb = new DemoGameBuilder();
break;
case "Small Game":
gb = new SmallGameBuilder();
break;
case "Classic Game":
gb = new ClassicGameBuilder();
break;
default:
gb = new DemoGameBuilder();
break;
}
gc.gameBuilder = gb;
gc.createGame();
parent.game = gc.getGame();
parent.game.list_players[0].name = NamePlayer1.Text;
parent.game.list_players[1].name = NamePlayer2.Text;
PageGame pg = new PageGame();
score scJ1 = new score(parent.game.list_players[0]);
score scJ2 = new score(parent.game.list_players[1]);
parent.center.Navigate(pg);
parent.ScoreJ1.Navigate(scJ1);
parent.ScoreJ2.Navigate(scJ2);
parent.ScoreJ1.Visibility = Visibility.Visible;
parent.ScoreJ2.Visibility = Visibility.Visible;
parent.listScore.Add(scJ1);
parent.listScore.Add(scJ2);
}
public unsafe void TestDemoBuilder()
{
GameCreator gc = new GameCreator();
gc.setPeopleJ1("elf");
gc.setPeopleJ2("human");
GameBuilder gb = new DemoGameBuilder();
gc.gameBuilder = gb;
gc.createGame();
Game game = gc.getGame();
Assert.AreEqual(game.maxTurnNumber, 5);
}
// Start is called before the first frame update
void Awake()
{
replays = new List <Replay>();
foreach (var replay in replaysToLoad)
{
replays.Add(Replay.ImportFromTextAsset(replay, Replay.SerializationStyle.ProtoBufNet));
}
creator = FindObjectOfType <GameCreator>();
creator.focusGameIndexOverride = FocusGame;
creator.focusNextOverride = NextGame;
creator.focusPrevOverride = PrevGame;
creator.OnNewGeneration.AddListener(NewGen);
}
public void CreateGame_VadidSettings_GameCreatedEventInvokation()
{
// arrange
GameCreator testGameCreator = new GameCreator();
bool wasEventCalled = false;
IGame newCreatedGame = null;
testGameCreator.NotifyOnGameCreated += (newGame) => { wasEventCalled = true; newCreatedGame = newGame; };
// act
testGameCreator.CreateGame(_defaultSettings, _manipulatorMock.Object);
// assert
_manipulatorMock.Verify(m => m.ShuffleBoard(newCreatedGame.Playfield, _defaultSettings.Level), Times.Once());
Assert.IsTrue(wasEventCalled);
}
private void Awake()
{
if (Instance == null)
{
Instance = this;
}
if (Instance != this)
{
Destroy(gameObject);
}
if (Persistent)
{
DontDestroyOnLoad(gameObject);
}
}
// Verifier validite des infos au clic sur le bouton valider
private void Valider(object sender, RoutedEventArgs e)
{
if (this.pseudoJ1.Text == "")
{
MessageBox.Show("Veuillez renseigner le pseudo du Player 1");
}
else if (this.pseudoJ2.Text == "")
{
MessageBox.Show("Veuillez renseigner le pseudo du Player 2");
}
else if (this.choixPeupleJ1 == null)
{
MessageBox.Show("Veuillez choisir un faction pour le Player 1");
}
else if (this.choixPeupleJ2 == null)
{
MessageBox.Show("Veuillez choisir un faction pour le Player 2");
}
else if (this.pseudoJ1.Text == this.pseudoJ2.Text)
{
MessageBox.Show("Veuillez choisir des pseudos différents");
}
else if (this.choixPeupleJ1.GetType() == this.choixPeupleJ2.GetType())
{
MessageBox.Show("Veuillez choisir des factions différents");
}
if (this.map == null)
{
MessageBox.Show("Veuillez choisir une map");
}
else
{
GameCreator dieu = new GameCreator(this.map);
this.game = dieu.buildGame(this.pseudoJ1.Text, this.choixPeupleJ1, this.pseudoJ2.Text, this.choixPeupleJ2);
FenetreCarte frm = new FenetreCarte(this.game);
this.mwindow.Close();
frm.Show();
}
}
// Start is called before the first frame update
public override void OnInspectorGUI()
{
var manager = ((LoadReplayManager)serializedObject.targetObject);
if (manager.replaysToLoad != null && manager.replaysToLoad.Length != 0)
{
GUILayout.TextArea("CurrentReplay: " + manager.replayNames[manager.focusIndex]);
}
base.OnInspectorGUI();
if (GUILayout.Button("Select Folder"))
{
string path = LoadGenomeManagerEditor.AssetsRelativePath(EditorUtility.OpenFolderPanel("Select Replay Folder", "", ""));
if (path.Length != 0)
{
string[] files = Directory.GetFiles(path);
List <TextAsset> replayFiles = new List <TextAsset>();
var assets = AssetDatabase.FindAssets("t:TextAsset", new[] { path });
List <string> fileNemse = new List <string>();
foreach (var asset in assets)
{
if (!AssetDatabase.GUIDToAssetPath(asset).EndsWith("bytes"))
{
continue;
}
replayFiles.Add(AssetDatabase.LoadAssetAtPath <TextAsset>(AssetDatabase.GUIDToAssetPath(asset)));
fileNemse.Add(AssetDatabase.GUIDToAssetPath(asset));
}
((LoadReplayManager)serializedObject.targetObject).replaysToLoad = replayFiles.ToArray();
((LoadReplayManager)serializedObject.targetObject).replayNames = fileNemse.ToArray();
GameCreator creator = FindObjectOfType <GameCreator>();
creator.gamesToShow = 4;
creator.gamesToCreate = replayFiles.Count;
creator.inspectionMode = true;
serializedObject.Update();
EditorUtility.SetDirty(creator);
}
}
}
/// <summary>
/// Init this brick with the given state
/// </summary>
/// <param name="thisBrickType"></param>
/// <param name="creator"></param>
public void SetStateThisBrick(BrickType thisBrickType, GameCreator creator)
{
m_IsDestroyed = false;
m_ThisBrickType = thisBrickType;
m_Creator = creator;
switch (m_ThisBrickType)
{
case BrickType.Normal:
this.GetComponent <MeshRenderer>().material = m_NormalMaterial;
this.GetComponent <MeshRenderer>().material.color = Color.white;
break;
case BrickType.PowerUp_Life:
this.GetComponent <MeshRenderer>().material = m_LifeMaterial;
break;
case BrickType.PowerUp_Speed:
this.GetComponent <MeshRenderer>().material = m_SpeedMaterial;
break;
case BrickType.PowerUp_Ball:
this.GetComponent <MeshRenderer>().material = m_BallMaterial;
break;
case BrickType.Strong:
this.GetComponent <MeshRenderer>().material = m_NormalMaterial;
this.GetComponent <MeshRenderer>().material.color = Color.gray;
break;
case BrickType.SuperStrong:
this.GetComponent <MeshRenderer>().material = m_NormalMaterial;
this.GetComponent <MeshRenderer>().material.color = Color.black;
break;
}
}
void Start()
{
gameArraySize.x = gameArrayWidth;
gameArraySize.y = gameArrayHeight;
screenSize = new IntVector2(Screen.width, Screen.height);
float blockWidthTemp = screenSize.x / gameArraySize.x;
float blockHeightTemp = screenSize.y / gameArraySize.y;
float minTemp = Mathf.Min(blockWidthTemp, blockHeightTemp);
blockPixelSize.x = Mathf.RoundToInt(Mathf.Floor(minTemp));
blockPixelSize.y = Mathf.RoundToInt(Mathf.Floor(minTemp));
blockArrayHolder = new GameObject("blockArrayHolder");
blockArrayHolder.transform.SetParent(this.transform);
gameCreator = new GameCreator();
gameCreator.createGame(this.transform, blockArrayHolder.transform, gameArraySize, texCircle, texLine, texDashed, texBlock, texClear, blockPixelSize, screenSize, percentFree);
}
public void game_creator_creates_two_bots()
{
var gameCreator = new GameCreator(this);
gameCreator.CreateGame("bot1", "bot2");
Assert.That(_botsCreated, Is.EqualTo(2));
}
public RegisterController(Database database, GameCreator gameCreator, PasswordHashing passwordHashing)
{
_database = database;
_gameCreator = gameCreator;
_passwordHashing = passwordHashing;
}
private void Start()
{
player = GameObject.Find("Player(Clone)").GetComponent <Player>();
gameCreator = GameObject.Find("Config").GetComponent <GameCreator>();
}
public ActionResult Schedule(SelectionViewModel vm)
{
if (!ModelState.IsValid)
{
ViewBag.GameSelectionTitle = "Schedule Game - Details";
ViewBag.GameSelectionButton = "Schedule";
ViewBag.ReturnTo = Url.Action("Select", "Game", new {vm.Activity, vm.Size, vm.Date, vm.SlotId });
ViewBag.CancelUrl = Url.Action("Slot", "Game", new { vm.Activity, vm.Size, vm.Date });
return View(vm);
}
GameCreationResult result = new GameCreator(Context, Server.MapPath("/bin")).Create(vm.SlotId,
vm.Team1Id,
vm.Team2Id,
MapActivity(vm.Activity),
vm.Notes,
vm.AreRefereesNeeded,
LoggedInUser);
if (result == GameCreationResult.SlotNotAvailable)
{
TempData["message"] = "That slot is no longer available.";
return RedirectToAction("Slot", "Game", new { vm.Activity, vm.Size, vm.Date });
}
TempData["message"] = "Game scheduled!";
return RedirectToAction("Slot", "Game", new { vm.Activity, vm.Size, vm.Date });
}
private void Awake()
{
instance = this;
Load();
}
public NewGameController(Database database, GameCreator gameCreator, BotCreator botCreator)
{
_database = database;
_gameCreator = gameCreator;
_botCreator = botCreator;
}
public GameStateController(Database database, GameCreator gameCreator)
{
_database = database;
_gameCreator = gameCreator;
}
