private void SetupMemory() { GameObject go = new GameObject("Memory"); controller = new GameObject().AddComponent <MemoryController>(); shortTermInfluencer = new GameObject("ShortTermInfluencer"); shortTermNegativeInfluencer = new GameObject("ShortTermInfluencer1"); shortTermMemory = ScriptableObject.CreateInstance <MemorySO>(); shortTermMemory.about = shortTermInfluencer; shortTermMemory.statName = "ShortTermTest"; shortTermMemory.influence = 5; shortTermMemory.cooldown = 0.1f; shortTermMemoryNegativeInflunce = ScriptableObject.CreateInstance <MemorySO>(); shortTermMemoryNegativeInflunce.about = shortTermNegativeInfluencer; shortTermMemoryNegativeInflunce.statName = "ShortTermTestNegativeInfluence"; shortTermMemoryNegativeInflunce.influence = -5; longTermInfluencer = new GameObject("LongTermInfluencer"); longTermMemory = ScriptableObject.CreateInstance <MemorySO>(); longTermMemory.about = longTermInfluencer; longTermMemory.statName = "LongTermTest"; longTermMemory.influence = 50; longTermMemory.cooldown = 0; // Validate setup Assert.Zero(controller.GetShortTermMemories().Length, "There are short term memories in a new Memory Controller"); Assert.Zero(controller.GetLongTermMemories().Length, "There are long term memories in a new Memory Controller"); }
private void AddScore() { SetConnection(); int score = MemoryController.CalculateScore(); MemoryInsertScore(score); }
public void Add_AddsEmployeeAndReturnsARedirect_WhenModelStateIsValid() { //Arrange var mockMemoryService = new Mock <IService <IRepository <Memory>, Memory> >(); mockMemoryService.Setup(repo => repo.GetByIdAsync(1)).ReturnsAsync(GetMemory()) .Verifiable(); var httpContext = new DefaultHttpContext(); var tempData = new TempDataDictionary(httpContext, Mock.Of <ITempDataProvider>()); var controller = new MemoryController(mockMemoryService.Object) { TempData = tempData }; controller.ModelState.AddModelError("Quantity", "Required"); var inputModel = new PCItemInputModel() { Id = 1, Quantity = 1 }; // Act var result = controller.Add(inputModel); // Assert Assert.IsType <JsonResult>(result.Result); mockMemoryService.Verify(); }
private void OnTriggerEnter(Collider other) { if (other.tag == "Player") { int reqCount = 0; MemoryController mem = other.GetComponent <MemoryController>(); for (int i = 0; i < requirements.Length; i++) { if (mem.MemoryContains(requirements[i])) { reqCount++; } } if (reqCount >= count) { //Handle win condition GameController.instance.EndGame(); } else { mem.ShowPopup("You still need " + (count - reqCount) + " launch codes! Return here once you've found them"); } } }
void Start() { int value = Random.Range(0, pairs.Count); figure = pairs[value]; pairs.RemoveAt(value); figureLabel.text = figure; controller = transform.parent.gameObject.GetComponent <MemoryController>(); }
public Cpu80186(ILogger <Cpu80186> logger, EventToken eventToken, MemoryController memoryController, DeviceManager devices, ProgrammableInterruptTimer8253 pit, ProgrammableInterruptController8259 pic) : base(logger, eventToken, memoryController, devices, pit, pic) { }
public GameBoy() { var ram = new Ram(); var cartridge = new Cartridge(); _memory = new MemoryController(ram, cartridge); _cpu = new Cpu(_memory); _compositor = new Compositor(_memory); }
// Start is called before the first frame update void Start() { panelWin.gameObject.SetActive(false); _powerUpController = GetComponent <PowerUpController>(); _memoryController = GetComponent <MemoryController>(); foreach (GameObject obj in GameObject.FindGameObjectsWithTag("Player")) { _players.Add(obj.GetComponent <PlayerMoviment>()); } }
public MemorySystem(uint id, uint megsOfMemory, ref Stream dramsim_log_) { dramsim_log = dramsim_log_; ReturnReadData = null; WriteDataDone = null; currentClockCycle = 0; if (Config.DEBUG_MEMORY) { DEBUG.WriteLine("===== MemorySystem " + systemID + " ====="); } UInt64 megsOfStoragePerRank = ((((UInt64)Config.dram_config.NUM_ROWS * (Config.dram_config.NUM_COLS * Config.dram_config.DEVICE_WIDTH) * Config.dram_config.NUM_BANKS) * ((UInt64)Config.dram_config.JEDEC_DATA_BUS_BITS / Config.dram_config.DEVICE_WIDTH)) / 8) >> 20; // If this is set, effectively override the number of ranks if (megsOfMemory != 0) { Config.dram_config.NUM_RANKS = (uint)(megsOfMemory / megsOfStoragePerRank); Config.dram_config.NUM_RANKS_LOG = Config.dram_config.log2(Config.dram_config.NUM_RANKS); if (Config.dram_config.NUM_RANKS == 0) { if (Config.DEBUG_MEMORY) { DEBUG.WriteLine("WARNING: Cannot create memory system with " + megsOfMemory + "MB, defaulting to minimum size of " + megsOfStoragePerRank + "MB"); } Config.dram_config.NUM_RANKS = 1; } } Config.dram_config.NUM_DEVICES = Config.dram_config.JEDEC_DATA_BUS_BITS / Config.dram_config.DEVICE_WIDTH; Config.dram_config.TOTAL_STORAGE = (Config.dram_config.NUM_RANKS * megsOfStoragePerRank); if (Config.DEBUG_MEMORY) { DEBUG.WriteLine("CH. " + systemID + " TOTAL_STORAGE : " + Config.dram_config.TOTAL_STORAGE + "MB | " + Config.dram_config.NUM_RANKS + " Ranks | " + Config.dram_config.NUM_DEVICES + " Devices per rank"); } memoryController = new MemoryController(this, dramsim_log); // TODO: change to other vector constructor? ranks = new List <Rank>(); for (int i = 0; i < Config.dram_config.NUM_RANKS; i++) { Rank r = new Rank(dramsim_log); r.setId(i); r.attachMemoryController(memoryController); ranks.Add(r); } memoryController.attachRanks(ranks); }
public void ExecuteInstruction3Test() { long[] program = { 10002, 2, 2, 1 }; MemoryController memoryController = new MemoryController(program); long pc = 0; var instruction02 = InstructionUtils.GetInstruction(program, 0, new ConsoleInput(), new ConsoleOutput(), memoryController); instruction02?.Execute(program, ref pc); Assert.Equal(4, program[3]); }
public Cpu8086(ILogger <Cpu8086> logger, EventToken eventToken, MemoryController memoryController, DeviceManager devices, ProgrammableInterruptTimer8253 pit, ProgrammableInterruptController8259 pic) : base(logger, memoryController, pit, pic) { this.eventToken = eventToken; this.devices = devices; }
protected override void OnStart() { base.OnStart(); _memoryController = _controller as MemoryController; _memoryController.RotateCards += Rotate; _bootstrap.Reset += ResetCard; ResetCard(); }
public void LoadCartridge(string file) { var ram = new Ram(); var cartridge = new Cartridge(); cartridge.LoadFromFile(file); _memory = new MemoryController(ram, cartridge); _cpu = new Cpu(_memory); _compositor = new Compositor(_memory); _cpu.Init(); }
public void ExecuteInstruction1Test() { long[] program = new long[] { 10001, 1, 1, 1 }; long pc = 0; MemoryController memoryController = new MemoryController(program); var instruction01 = InstructionUtils.GetInstruction(program, 0, new ConsoleInput(), new ConsoleOutput(), memoryController); instruction01?.Execute(program, ref pc); Assert.Equal(2, program[3]); }
public void ExecuteInstruction2Test() { long[] program = { 1002, 4, 3, 4, 33 }; long[] expected = { 1002, 4, 3, 4, 99 }; MemoryController memoryController = new MemoryController(program); long pc = 0; var instruction01 = InstructionUtils.GetInstruction(program, 0, new ConsoleInput(), new ConsoleOutput(), memoryController); instruction01?.Execute(program, ref pc); Assert.Equal(expected, program); }
private void Awake() { DontDestroyOnLoad(gameObject); if (_instance != null && _instance != this) { Destroy(this.gameObject); } else { _instance = this; DontDestroyOnLoad(gameObject); } }
private IEnumerator endGame() { MemoryController.SelectNumber = selected; yield return(new WaitForSeconds(1)); if (MemoryController.IsLastGame()) { AddScore(); SceneManager.LoadScene("MemoryResult"); } else { MemoryController.NextGame(); SceneManager.LoadScene("MemoryStart"); } }
private string GetResult() { switch (Game) { case Game.Memory: return(MemoryController.GetResult()); case Game.Dexterity: return(DexterityController.GetResult()); case Game.Math: return(MathController.GetResult()); default: return(""); } }
protected void Dispose(Boolean itIsSafeToAlsoFreeManagedObjects) { //Free managed resources too, but only if I'm being called from Dispose //(If I'm being called from Finalize then the objects might not exist anymore if (!itIsSafeToAlsoFreeManagedObjects) { return; } if (MemoryController == null) { return; } MemoryController.Dispose(); MemoryController = null; }
private IEnumerator loadButton(string scene) { yield return(new WaitForSeconds(EyeCursor.Time())); if (EyeCursor.IsFocused()) { EyeCursor.Off(); if (scene == "MemoryStart") { MemoryController.ClearResult(); } else if (scene == "DexterityGame") { MemoryController.ClearResult(); } SceneManager.LoadScene(scene); } }
public void Add_ReturnsBadRequestResult_WhenModelStateIsInvalid() { // Arrange var mockMemoryService = new Mock <IService <IRepository <Memory>, Memory> >(); var inputModel = new PCItemInputModel() { Id = 0, Quantity = 0 }; var controller = new MemoryController(mockMemoryService.Object); controller.ModelState.AddModelError("Quantity", "Required"); // Act var result = controller.Add(inputModel); // Assert var badRequestResult = Assert.IsType <BadRequestResult>(result.Result); }
public CrtController6845(MemoryController memoryController, EventToken eventToken) { this.memoryController = memoryController; registers = new byte[0x12]; buffer = Array.Empty <short>(); fillTextBuffer = () => { }; ChangeResolution(textStartOfs == SpecialOffset.ColorText ? VideoMode.Text80x25Color : VideoMode.Text80x25TextMonochrome); if (isWindows) { SetConsoleOutputCP(437); consoleHandle = GetStdHandle(StdOutputHandle); } var shutdownCancellationToken = eventToken.ShutDown.Token; // task to copy the text video memory to the console buffer Task = Task.Run(async() => { while (!shutdownCancellationToken.IsCancellationRequested) { var task = Task.Delay(RefreshDelay, shutdownCancellationToken); if (isWindows) { CopyMemoryToConsoleBuffer(); } else { WriteMemoryToConsole(); } if (cursorPositionChanged) { cursorPositionChanged = false; SetCursorPosition((registers[RegisterCursorAddrHi] << 8) | registers[RegisterCursorAddrLo]); } await task; } }); }
public async Task Index_ReturnsAViewResult_WithAListOfMemorys() { // Arrange var mockMemoryService = new Mock <IService <IRepository <Memory>, Memory> >(); mockMemoryService.Setup(repo => repo.GetAllAsync()) .ReturnsAsync(GetTestMemorys()); var controller = new MemoryController(mockMemoryService.Object); // Act var result = await controller.Index(); // Assert var viewResult = Assert.IsType <ViewResult>(result); var model = Assert.IsAssignableFrom <IEnumerable <Memory> >( viewResult.ViewData.Model); Assert.Equal(2, model.Count()); }
void OpenScene(ButtonName name) { switch (name) { case ButtonName.Initialize: SceneManager.LoadScene("Initialize"); break; case ButtonName.Menu: SceneManager.LoadScene("Menu"); break; case ButtonName.MemoryStartMenu: SceneManager.LoadScene("MemoryStartMenu"); break; case ButtonName.DexterityStartMenu: SceneManager.LoadScene("DexterityStartMenu"); break; case ButtonName.StartMemory: MemoryController.ClearResult(); SceneManager.LoadScene("MemoryStart"); break; case ButtonName.StartDexterity: MemoryController.ClearResult(); SceneManager.LoadScene("DexterityGame"); break; case ButtonName.MathStartMenu: SceneManager.LoadScene("MathStartMenu"); break; case ButtonName.StartMath: SceneManager.LoadScene("MathGame"); break; default: break; } }
public DSystem() { _scheduler = new Scheduler(); _cp = new CentralProcessor(this); _iop = new IOProcessor(this); _memoryController = new MemoryController(); _displayController = new DisplayController(this); _hardDrive = new SA1000Drive(this); _shugartController = new ShugartController(this, _hardDrive); _ethernetController = new EthernetController(this); try { _frameTimer = new FrameTimer(38.7); } catch { // Not supported on this platform. _frameTimer = null; } }
public void TestPrintProgram() { var cart = new Cartridge(); cart.LoadFromFile("../../../test_programs/print_test.rom"); var ram = new Ram(); var memoryController = new MemoryController(ram, cart); var cpu = new Cpu(memoryController); cpu.Init(); // Need to figure out halt... bool done = false; int iterations = 0; while (!done && iterations++ < 10000) { cpu.ExecuteNextInstruction(); } }
private void Awake() { m_Memory = GetComponent <MemoryController>(); }
public Cartridge(string romFile) { using (FileStream fs = new FileStream(romFile, FileMode.Open, FileAccess.Read, FileShare.Read)) { // Read in the first ROM bank, which also contains the cartridge header rom0 = new byte[0x4000]; fs.Read(rom0, 0, 0x4000); // Check to make sure that this is an actual GameBoy ROM File by checking the logo in the header // (CGB only checks first 18 bytes, so that's what we will do) for (int i = 0, addr = 0x0104; i < LogoData.Length; i++, addr++) { if (addr >= rom0.Length || rom0[addr] != LogoData[i]) { throw new FileFormatException("File is not a valid GameBoy ROM"); } } // Get the number of ROM and RAM banks from the cartridge header. int romSize = rom0[0x0148]; switch (romSize) { case 0x52: romSize = 0x4000 * 72; break; // Awkward sizes case 0x53: romSize = 0x4000 * 80; break; case 0x54: romSize = 0x4000 * 92; break; default: romSize = 0x8000 << romSize; break; } int ramSize = rom0[0x0149]; switch (ramSize) // 0 => 0, 1 => 1 { case 0: ramSize = 0; break; case 1: ramSize = 0x800; break; case 2: ramSize = 0x2000; break; case 3: ramSize = 0x2000 * 4; break; case 4: ramSize = 0x2000 * 16; break; case 5: ramSize = 0x2000 * 8; break; } // Determine cartridge features switch (rom0[0x0147]) { default: throw new NotSupportedException("Cartridge type not supported."); case 9: hasBattery = true; goto case 8; case 8: case 0: mbc = new ROMOnlyController(ramSize); break; case 3: hasBattery = true; goto case 2; case 2: case 1: mbc = new MBC1(romSize, ramSize); break; case 6: hasBattery = true; goto case 5; case 5: mbc = new MBC2(romSize); break; case 16: case 15: hasBattery = true; mbc = new MBC3(romSize, ramSize, true); break; case 19: hasBattery = true; goto case 18; case 18: case 17: mbc = new MBC3(romSize, ramSize, false); break; } mbc.LoadROM(fs); } storageFile = Path.Combine(StoragePath, Path.ChangeExtension(Path.GetFileName(romFile), BatteryExtension)); if (hasBattery && File.Exists(storageFile)) { mbc.LoadStorageRAM(storageFile); } }
public void attachMemoryController(MemoryController memoryController) { this.memoryController = memoryController; }
public static MemoryController GetMemoryController(IMemoryControllerOutput output) { var memoryController = new MemoryController(output); return(memoryController); }