public void NewGame()
{
MemorySystem.SaveData(Gamemanager.instance.gameData);
SceneManager.LoadScene(1);
btnLoadGame.gameObject.SetActive(false);
Gamemanager.instance.Score.gameObject.SetActive(true);
}
public void Setup()
{
_assertVisitor = new AssertVisitor();
_valueFactory = new ValueFactory();
_interpreter = new InterpreterVisitor(_valueFactory);
_memory = new MemorySystem();
}
public void NewGame()
{
if (gameNameIF.text == null)
{
return;
}
MemorySystem.NewGame(gameNameIF.text);
}
void SaveProgress()
{
PlayerPrefs.SetInt("CurrentMoney", playerMoney);
PlayerPrefs.SetInt("CurrentLevel", currentLevel);
SystemData_Update();
MemorySystem.SaveFile(data);
}
public Module(Kernel kernel)
{
Debug.Assert(kernel != null);
_kernel = kernel;
_memory = _kernel.Memory;
_memorySystem = _kernel.MemorySystem;
}
new void Update()
{
base.Update();
if (Btn_Submit)
{
GameData gd = MemorySystem.LoadData("MyCoolGame.data");
transform.position = gd.PosVector;
}
}
void Save()
{
if (string.IsNullOrEmpty(fileName.text))
{
return;
}
MemorySystem.SaveData(Gamemanager.instance.gameData, fileName.text);
gameObject.SetActive(false);
}
// -- SETTERS ----------
void SetComponents()
{
player = GameObject.FindGameObjectWithTag("Player").transform;
head = GameObject.Find("Player").transform;
memorySystem = GetComponent <MemorySystem>();
agent = GetComponent <NavMeshAgent>();
brain = GetComponentInChildren <BeingHead>();
head = GenericHelper.FindChildTransformWithTag("Head", transform);
debugTextMesh = GenericHelper.FindChildTransformWithTag("DebugTextMesh", head).GetComponent <TextMesh>();
}
/*
* private void Update()
* {
* if (Input.GetButtonDown("Fire1"))
* {
* MemorySystem.Save(new GameData(GetComponent<Transform>().position.x,
* GetComponent<Transform>().position.y), "save.data");
* print("saved");
* }
* }
*/
private void OnTriggerEnter(Collider other)
{
if (other.tag == "Save")
{
MemorySystem.Save(new GameData(GetComponent <Transform>().position.z,
GetComponent <Transform>().position.y), "save.data");
//print("saved at: " + GetComponent<Transform>().position.z + " -- " +
// GetComponent<Transform>().position.y);
}
}
public void SystemData_Check()
{
if (data == null)
{
data = MemorySystem.LoadFile();
if (data == null)
{
data = new MemorySystemData();
}
}
}
void Awake()
{
memorySystem = GetComponentInParent <MemorySystem>();
if (memorySystem == null)
{
throw new Exception("MemorySystem required to be a parent of MemoryComponent");
}
memorySystem.RegisterEvent(new MemorySystem.RememberEvent());
memorySystem.RegisterEvent(new MemorySystem.ForgetEvent());
agent = GetComponent <AgentBase>();
}
void Awake()
{
if (MemorySystem.loadGame)
{
GameData gd = MemorySystem.LoadData("save.data");
MemorySystem.loadGame = false;
Vector3 pos = GetComponent <Transform>().position;
GetComponent <Transform>().position = new Vector3(pos.x, gd.PosY, gd.PosX);
//print("load at: " + new Vector3(pos.x, gd.PosY, gd.PosX));
}
}
public MGLDriver(IEmulationInstance emulator, ComponentParameters parameters)
{
this.Emu = emulator;
this.MemorySystem = this.Emu.Cpu.Memory.MemorySystem;
_parameters = parameters;
_caps = new MGLCapabilities();
this.Properties = new DisplayProperties();
_statisticsSource = new MGLStatisticsSource(this);
Diag.Instance.Counters.RegisterSource(_statisticsSource);
}
// manual add
public int sceDmacMemcpy(int dest, int source, int size)
{
unsafe
{
byte *pdest = _memorySystem.Translate(( uint )dest);
byte *psrc = _memorySystem.Translate(( uint )source);
MemorySystem.CopyMemory(psrc, pdest, ( uint )size);
}
return(0);
}
private static void GetVertexComponentSize(uint[] sizes, uint[] aligns, uint type, uint count, ref uint biggest, ref uint size)
{
if (sizes[type] != 0)
{
size = MemorySystem.Align(size, aligns[type]);
size += sizes[type] * count;
if (aligns[type] > biggest)
{
biggest = aligns[type];
}
}
}
public unsafe int WriteTime(uint address, DateTime value)
{
ushort *p = ( ushort * )MemorySystem.Translate(address);
*p = ( ushort )value.Year;
*(p + 1) = ( ushort )value.Month;
*(p + 2) = ( ushort )value.Day;
*(p + 3) = ( ushort )value.Hour;
*(p + 4) = ( ushort )value.Minute;
*(p + 5) = ( ushort )value.Second;
*(( int * )(p + 6)) = value.Millisecond * 1000;
return(16);
}
public unsafe int WriteString(uint address, string value)
{
byte *p = MemorySystem.Translate(address);
byte *sp = p;
for (int n = 0; n < value.Length; n++)
{
char c = value[n];
* sp = ( byte )c;
sp++;
}
*sp = 0;
return(value.Length + 1);
}
private void RebuildQuestionnaireCommand_Execute(string questionnaireInput)
{
var parsingTask = _parsingPipeline.Process(new ParsingTask(questionnaireInput));
if (parsingTask.Errors.Count > 0)
{
_mainViewModel.QuestionnaireValidation = parsingTask.Errors.Aggregate(
$"Validation failed! There are {parsingTask.Errors.Count} error(s) in your questionnaire.",
(err, acc) => err + Environment.NewLine + acc);
return;
}
_symbols = parsingTask.SymbolTable;
_mainViewModel.QuestionnaireValidation = "Validation succeeded! Enjoy your questionnaire";
_memory = new MemorySystem();
RebuildQuestionnaire(parsingTask.Ast);
}
void FixedUpdate()
{
if (GameplaySystem.JumpBtn)
{
if (Grounding)
{
Gamemanager.instance.gameData.PlayerPos = transform.position;
//Debug.Log(Gamemanager.instance.gameData.Player);
// Gamemanager.instance.Save();
MemorySystem.SaveData(gd, gd.gameData);
anim.SetTrigger("jump");
GameplaySystem.Jump(rb2D, jumpForce);
}
}
anim.SetBool("grounding", Grounding);
//GameplaySystem.MovementAddForce(rb2D, moveSpeed, maxVel, Grounding);
GameplaySystem.MovementVelocity(rb2D, moveSpeed, maxVel);
}
public unsafe DateTime ReadTime(uint address)
{
ushort *p = ( ushort * )MemorySystem.Translate(address);
//unsigned short year
//unsigned short month
//unsigned short day
//unsigned short hour
//unsigned short minute
//unsigned short second
//unsigned int microsecond
return(new DateTime(
*p,
*(p + 1),
*(p + 2),
*(p + 3),
*(p + 4),
*(p + 5),
*(( int * )(p + 6)) / 1000));
}
private static uint DetermineVertexSize(uint vertexType, out uint alignmentDelta)
{
// Kindly yoinked (with permission) from ector's DaSh
uint positionType = (vertexType & VertexType.PositionMask) >> 7;
uint normalType = (vertexType & VertexType.NormalMask) >> 5;
uint textureType = (vertexType & VertexType.TextureMask);
uint weightCount = ((vertexType & VertexType.WeightCountMask) >> 14) + 1;
uint weightType = (vertexType & VertexType.WeightMask) >> 9;
uint colorType = (vertexType & VertexType.ColorMask) >> 2;
uint morphCount = (vertexType & VertexType.MorphCountMask) >> 18;
uint size = 0;
uint biggest = 0;
if (weightType > 0)
{
GetVertexComponentSize(v_weightSizes, v_weightAlign, weightType, weightCount, ref biggest, ref size); // WRONG - count?
}
if (textureType > 0)
{
GetVertexComponentSize(v_textureSizes, v_textureAlign, textureType, 1, ref biggest, ref size);
}
if (colorType > 0)
{
GetVertexComponentSize(v_colorSizes, v_colorAlign, colorType, 1, ref biggest, ref size);
}
if (normalType > 0)
{
GetVertexComponentSize(v_normalSizes, v_normalAlign, normalType, 1, ref biggest, ref size);
}
GetVertexComponentSize(v_positionSizes, v_positionAlign, positionType, 1, ref biggest, ref size);
// do something with morph count?
Debug.Assert(morphCount == 0);
uint result = MemorySystem.Align(size, biggest);
alignmentDelta = result - size;
return(result);
}
// SDK location: /registry/pspreg.h:163
// SDK declaration: int sceRegGetKeyValue(REGHANDLE hd, REGHANDLE hk, void *buf, SceSize size);
public int sceRegGetKeyValue(int hd, int hk, int buf, int size)
{
RegistryHandle categoryHandle = this.GetHandle(hd);
if (categoryHandle == null)
{
return(-1);
}
RegistryHandle keyHandle = categoryHandle.GetHandle(hk);
if (keyHandle == null)
{
return(-1);
}
byte *pbuf = _memorySystem.TranslateMainMemory(buf);
switch (keyHandle.Key.Type)
{
case RegistryKeyType.Integer:
*(( int * )pbuf) = keyHandle.Key.ValueI;
break;
case RegistryKeyType.String:
_kernel.WriteString(( uint )buf, keyHandle.Key.ValueS);
break;
case RegistryKeyType.Binary:
{
byte[] value = keyHandle.Key.ValueB;
fixed(byte *pvalue = &value[0])
MemorySystem.CopyMemory(pvalue, pbuf, ( uint )value.Length);
}
break;
}
return(0);
}
public Kernel(Bios bios)
{
Debug.Assert(bios != null);
Bios = bios;
Emulator = Bios.Emulator;
Debug.Assert(Emulator.Cpu != null);
Cpu = Emulator.Cpu;
CpuCore = Cpu.Cores[0];
Memory = Cpu.Memory;
MemorySystem = Memory.MemorySystem;
Devices = new List <KDevice>();
UserModules = new List <KModule>(10);
Threads = new List <KThread>(128);
SchedulableThreads = new FastLinkedList <KThread>();
Handles = new Dictionary <uint, KHandle>();
_lastUid = 100;
SpeedLocked = true;
}
public void NewGame()
{
Gamemanager.instance.gameData = new GameData();
MemorySystem.SaveData(Gamemanager.instance.gameData);
LoadScene();
}
private void OnTriggerEnter2D(Collider2D collision)
{
MemorySystem.Save(new GameData(transform.position.x, transform.position.y));
}
protected override void ResetState()
{
commands = null;
memorySystem = null;
}
public InterpretingTask(Node ast, MemorySystem memory, SymbolTable symbols)
{
InitialAst = ast;
Memory = memory;
Symbols = symbols;
}
internal Node EvaluateAst(Node ast, MemorySystem memory, SymbolTable symbols)
{
_symbols = symbols;
_memory = memory;
return(ast.Accept(this));
}
public void LoadGame()
{
Gamemanager.instance.gameData = MemorySystem.LoadData();
LoadScene();
}
void UpdateHealthText()
{
txtHealth.text = $"Health: {healthValue}";
MemorySystem.NewGame(healthValue);
}
