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);
}
