From 2bfa7ba4d4782c5490302d737950846afd6fad22 Mon Sep 17 00:00:00 2001
From: Technus <daniel112092@gmail.com>
Date: Sat, 27 Jul 2019 16:22:04 +0200
Subject: probably working avr core

---
 .../tectech/mechanics/avr/SidedRedstone.java       | 248 +++++++++++++++++++++
 .../single/GT_MetaTileEntity_DataReader.java       |   2 +-
 ...T_MetaTileEntity_MicroControllerTileEntity.java | 169 ++++++++++++++
 .../tileEntity/MicroControllerTileEntity.java      | 118 ----------
 4 files changed, 418 insertions(+), 119 deletions(-)
 create mode 100644 src/main/java/com/github/technus/tectech/mechanics/avr/SidedRedstone.java
 create mode 100644 src/main/java/com/github/technus/tectech/thing/metaTileEntity/single/GT_MetaTileEntity_MicroControllerTileEntity.java
 delete mode 100644 src/main/java/com/github/technus/tectech/thing/tileEntity/MicroControllerTileEntity.java

(limited to 'src/main/java/com')

diff --git a/src/main/java/com/github/technus/tectech/mechanics/avr/SidedRedstone.java b/src/main/java/com/github/technus/tectech/mechanics/avr/SidedRedstone.java
new file mode 100644
index 0000000000..9488b9280f
--- /dev/null
+++ b/src/main/java/com/github/technus/tectech/mechanics/avr/SidedRedstone.java
@@ -0,0 +1,248 @@
+package com.github.technus.tectech.mechanics.avr;
+
+import com.github.technus.avrClone.AvrCore;
+import com.github.technus.avrClone.registerPackages.*;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+
+public class SidedRedstone extends RegisterPackageSync<IGregTechTileEntity> {
+    public static final RSINT RSINT =new RSINT();
+
+    public SidedRedstone(int offset) {
+        super(offset, 23);
+        addRegisters(Register.values());
+        addBits(RegisterBitsPCMSK.values());
+        addBits(RegisterBitsPCFR.values());
+        addBits(RegisterBitsPCINT.values());
+        addBits(RegisterBitsPNEW.values());
+        addBits(RegisterBitsPOLD.values());
+        addInterrupts(RSINT);
+    }
+
+    @Override
+    public void preSync(AvrCore core,IGregTechTileEntity iGregTechTileEntity) {
+        int addr=this.getOffset();
+        int sides=0;
+        for(byte i=0;i<6;i++){
+            int val=iGregTechTileEntity.getInternalInputRedstoneSignal(i);
+            sides|=(val > 0?1:0)<<i;
+            core.setDataValue(addr++,iGregTechTileEntity.getInputRedstoneSignal(i));
+            core.setDataValue(addr++,val);
+            addr++;
+        }
+        int sidesOld = core.getDataValue(Register.PNEW.getAddress(this));
+        core.setDataValue(Register.POLD.getAddress(this),sidesOld);
+        core.setDataValue(Register.PNEW.getAddress(this),sides);
+
+        if(core.getInterruptEnable()) {
+            int pcint=core.getDataValue(Register.PCINT.getAddress(this));
+            int changesDetected=0;
+            switch (pcint&0b1100){//PCISC1 PCISC0
+                case 0b0000://low
+                    changesDetected= ~sides & core.getDataValue(Register.PCMSK.getAddress(this));
+                    break;
+                case 0b0100://any
+                    changesDetected= (sides ^ sidesOld) & core.getDataValue(Register.PCMSK.getAddress(this));
+                    break;
+                case 0b1000://falling
+                    changesDetected= ~sides & sidesOld & core.getDataValue(Register.PCMSK.getAddress(this));
+                    break;
+                case 0b1100://rising
+                    changesDetected= sides & ~sidesOld & core.getDataValue(Register.PCMSK.getAddress(this));
+                    break;
+            }
+
+            core.setDataValue(Register.PCFR.getAddress(this),
+                    core.getDataValue(Register.PCFR.getAddress(this) | changesDetected));
+
+            if (changesDetected > 0) {
+                if (core.getDataBitsOr(Register.PCINT.getAddress(this), RegisterBitsPCINT.PCEN.mask)) {
+                    core.setDataBits(Register.PCINT.getAddress(this), RegisterBitsPCINT.PCIF.mask);
+                }
+            }
+        }
+    }
+
+    @Override
+    public void postSync(AvrCore core,IGregTechTileEntity iGregTechTileEntity) {
+        int addr=this.getOffset();
+        for(byte i=0;i<6;i++){
+            iGregTechTileEntity.setOutputRedstoneSignal(i,(byte)core.getDataValue(addr));//allows edge detection hack?
+            addr+=3;
+        }
+    }
+
+    public enum Register implements IRegister<SidedRedstone>{
+        PIN0,PINT0,PORT0,
+        PIN1,PINT1,PORT1,
+        PIN2,PINT2,PORT2,
+        PIN3,PINT3,PORT3,
+        PIN4,PINT4,PORT4,
+        PIN5,PINT5,PORT5,
+        PCMSK,PCFR,PCINT,PNEW,POLD;
+
+        public final int relativeOffset;
+
+        Register(){
+            this.relativeOffset =ordinal();
+        }
+
+        @Override
+        public int getAddress(SidedRedstone registerPackage) {
+            return registerPackage.getOffset()+relativeOffset;
+        }
+    }
+
+    public enum RegisterBitsPCMSK implements IRegisterBit<SidedRedstone>{
+        PCINT0,PCINT1,PCINT2,PCINT3,PCINT4,PCINT5;
+
+        private final int bit,mask;
+
+        RegisterBitsPCMSK(){
+            bit=ordinal();
+            mask=1<<bit;
+        }
+
+        @Override
+        public int getBitPosition() {
+            return bit;
+        }
+
+        @Override
+        public int getBitMask() {
+            return mask;
+        }
+
+        @Override
+        public int getOffset(SidedRedstone registerPackage) {
+            return 18;
+        }
+    }
+
+    public enum RegisterBitsPCFR implements IRegisterBit<SidedRedstone>{
+        PCF0,PCF1,PCF2,PCF3,PCF4,PCF5;
+
+        private final int bit,mask;
+
+        RegisterBitsPCFR(){
+            bit=ordinal();
+            mask=1<<bit;
+        }
+
+        @Override
+        public int getBitPosition() {
+            return bit;
+        }
+
+        @Override
+        public int getBitMask() {
+            return mask;
+        }
+
+        @Override
+        public int getOffset(SidedRedstone registerPackage) {
+            return 19;
+        }
+    }
+
+    public enum RegisterBitsPCINT implements IRegisterBit<SidedRedstone>{
+        PCIF,PCEN,PCISC0,PCISC1;
+
+        private final int bit,mask;
+
+        RegisterBitsPCINT(){
+            bit=ordinal();
+            mask=1<<bit;
+        }
+
+        @Override
+        public int getBitPosition() {
+            return bit;
+        }
+
+        @Override
+        public int getBitMask() {
+            return mask;
+        }
+
+        @Override
+        public int getOffset(SidedRedstone registerPackage) {
+            return 20;
+        }
+    }
+
+    public enum RegisterBitsPNEW implements IRegisterBit<SidedRedstone>{
+        PNEW0,PNEW1,PNEW2,PNEW3,PNEW4,PNEW5;
+
+        private final int bit,mask;
+
+        RegisterBitsPNEW(){
+            bit=ordinal();
+            mask=1<<bit;
+        }
+
+        @Override
+        public int getBitPosition() {
+            return bit;
+        }
+
+        @Override
+        public int getBitMask() {
+            return mask;
+        }
+
+        @Override
+        public int getOffset(SidedRedstone registerPackage) {
+            return 21;
+        }
+    }
+
+    public enum RegisterBitsPOLD implements IRegisterBit<SidedRedstone>{
+        POLD0,POLD1,POLD2,POLD3,POLD4,POLD5;
+
+        private final int bit,mask;
+
+        RegisterBitsPOLD(){
+            bit=ordinal();
+            mask=1<<bit;
+        }
+
+        @Override
+        public int getBitPosition() {
+            return bit;
+        }
+
+        @Override
+        public int getBitMask() {
+            return mask;
+        }
+
+        @Override
+        public int getOffset(SidedRedstone registerPackage) {
+            return 22;
+        }
+    }
+
+    public static class RSINT implements IInterrupt<SidedRedstone>{
+        @Override
+        public int getVector() {
+            return 1;
+        }
+
+        @Override
+        public boolean getTrigger(AvrCore core, SidedRedstone registerPackage) {
+            return (core.getDataValue(Register.PCINT.getAddress(registerPackage))&1)==1;
+        }
+
+        @Override
+        public void setTrigger(AvrCore core, SidedRedstone registerPackage, boolean value) {
+            int val=core.getDataValue(Register.PCINT.getAddress(registerPackage));
+            core.setDataValue(Register.PCINT.getAddress(registerPackage),
+                    value?val|RegisterBitsPCINT.PCIF.mask:val&~RegisterBitsPCINT.PCIF.mask);
+        }
+
+        @Override
+        public String name() {
+            return "RSINT";
+        }
+    }
+}
diff --git a/src/main/java/com/github/technus/tectech/thing/metaTileEntity/single/GT_MetaTileEntity_DataReader.java b/src/main/java/com/github/technus/tectech/thing/metaTileEntity/single/GT_MetaTileEntity_DataReader.java
index d8b230995f..6d594512bd 100644
--- a/src/main/java/com/github/technus/tectech/thing/metaTileEntity/single/GT_MetaTileEntity_DataReader.java
+++ b/src/main/java/com/github/technus/tectech/thing/metaTileEntity/single/GT_MetaTileEntity_DataReader.java
@@ -39,7 +39,7 @@ import static com.github.technus.tectech.recipe.TT_recipeAdder.nullItem;
  */
 public class GT_MetaTileEntity_DataReader extends GT_MetaTileEntity_BasicMachine {
     private static final HashMap<Util.ItemStack_NoNBT,ArrayList<IDataRender>> RENDER_REGISTRY =new HashMap<>();
-    private static GT_RenderedTexture READER_ONLINE, READER_OFFLINE;
+    public static GT_RenderedTexture READER_ONLINE, READER_OFFLINE;
 
     public GT_MetaTileEntity_DataReader(int aID, String aName, String aNameRegional, int aTier) {
         super(aID,aName,aNameRegional,aTier,1,"Reads Data Sticks and Orbs",1,1,"dataReader.png","");
diff --git a/src/main/java/com/github/technus/tectech/thing/metaTileEntity/single/GT_MetaTileEntity_MicroControllerTileEntity.java b/src/main/java/com/github/technus/tectech/thing/metaTileEntity/single/GT_MetaTileEntity_MicroControllerTileEntity.java
new file mode 100644
index 0000000000..6692c19cea
--- /dev/null
+++ b/src/main/java/com/github/technus/tectech/thing/metaTileEntity/single/GT_MetaTileEntity_MicroControllerTileEntity.java
@@ -0,0 +1,169 @@
+package com.github.technus.tectech.thing.metaTileEntity.single;
+
+import com.github.technus.avrClone.AvrCore;
+import com.github.technus.avrClone.instructions.ExecutionEvent;
+import com.github.technus.avrClone.instructions.Instruction;
+import com.github.technus.avrClone.instructions.InstructionRegistry;
+import com.github.technus.avrClone.instructions.exceptions.DebugEvent;
+import com.github.technus.avrClone.instructions.exceptions.DelayEvent;
+import com.github.technus.avrClone.memory.EepromMemory;
+import com.github.technus.avrClone.memory.RemovableMemory;
+import com.github.technus.avrClone.memory.program.ProgramMemory;
+import com.github.technus.tectech.TecTech;
+import com.github.technus.tectech.Util;
+import com.github.technus.tectech.mechanics.avr.SidedRedstone;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_TieredMachineBlock;
+import gregtech.api.objects.GT_RenderedTexture;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+
+import static com.github.technus.tectech.thing.metaTileEntity.single.GT_MetaTileEntity_DataReader.READER_OFFLINE;
+import static com.github.technus.tectech.thing.metaTileEntity.single.GT_MetaTileEntity_DataReader.READER_ONLINE;
+
+public class GT_MetaTileEntity_MicroControllerTileEntity extends GT_MetaTileEntity_TieredMachineBlock {
+    static {
+        Instruction.random= TecTech.RANDOM;
+    }
+    private AvrCore core;
+    private int[] tempData;
+    private boolean debugRun;
+    private int delay;
+
+    public static final SidedRedstone sidedRedstone=new SidedRedstone(0x1b);
+
+    public GT_MetaTileEntity_MicroControllerTileEntity(int aID, String aName, String aNameRegional, int aTier) {
+        super(aID, aName, aNameRegional, aTier, 0, "AVR Micro-controller");
+        Util.setTier(aTier,this);
+    }
+
+    public GT_MetaTileEntity_MicroControllerTileEntity(String aName, int aTier, String aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, 0, aDescription, aTextures);
+        Util.setTier(aTier,this);
+        core=new AvrCore();
+        core.setUsingImmersiveOperands(false);
+        core.setInstructionRegistry(InstructionRegistry.INSTRUCTION_REGISTRY_OP);
+        core.setDataMemory(1<<aTier,1<<aTier);
+        core.setCpuRegisters(0x30);
+        core.putDataBindings(sidedRedstone);
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity iGregTechTileEntity) {
+        return new GT_MetaTileEntity_MicroControllerTileEntity(mName, mTier, mDescription, mTextures);
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound tag) {
+        debugRun=tag.getBoolean("debugRun");
+        delay=tag.getInteger("delay");
+        core.active =tag.getBoolean("active");
+        core.awoken=(tag.getBoolean("awoken"));
+        core.programCounter=tag.getInteger("programCounter");
+        if(tag.hasKey("instructions")){
+            int[] instructions=tag.getIntArray("instructions");
+            int[] param0=tag.getIntArray("param0");
+            int[] param1=tag.getIntArray("param1");
+            core.setProgramMemory(new ProgramMemory(
+                    core.getInstructionRegistry(),core.isUsingImmersiveOperands(),
+                    instructions,param0,param1));
+        }
+        if(tag.hasKey("eepromSize")){
+            core.setEepromDefinition(EepromMemory.make(tag.getInteger("eepromSize")));
+        }
+        if(tag.hasKey("dataMemory")){
+            tempData=tag.getIntArray("dataMemory");
+        }
+        core.checkValid();
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound tag) {
+        tag.setBoolean("debugRun",debugRun);
+        tag.setInteger("delay",delay);
+        tag.setBoolean("active",core.active);
+        tag.setBoolean("awoken",core.awoken);
+        tag.setInteger("programCounter",core.programCounter);
+        ProgramMemory programMemory=core.getProgramMemory();
+        if(programMemory!=null){
+            tag.setIntArray("instructions",programMemory.instructions);
+            tag.setIntArray("param0",programMemory.param0);
+            tag.setIntArray("param1",programMemory.param1);
+        }
+        RemovableMemory<EepromMemory> eeprom=core.getEepromMemory();
+        if(eeprom!=null){
+            tag.setInteger("eepromSize",eeprom.getDefinition().getSize());
+        }
+        if(core.dataMemory!=null){
+            tag.setIntArray("dataMemory",core.dataMemory);
+        }
+    }
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+        if (tempData != null) {
+            //todo discovery of components
+            core.dataMemory = tempData;
+            tempData = null;
+        }
+        if (core.active) {
+            sidedRedstone.preSync(core,aBaseMetaTileEntity);
+            core.interruptsHandle();
+            if (core.awoken) {
+                delay=0;
+                for (int i = 0, cycles = Math.min(1 << mTier, 512); i < cycles; i++) {
+                    ExecutionEvent executionEvent = core.cpuCycleForce();
+                    if (executionEvent != null) {
+                        if (executionEvent.throwable instanceof DelayEvent) {
+                            delay = executionEvent.data[0];
+                            break;
+                        } else if (debugRun && executionEvent.throwable instanceof DebugEvent) {
+                            core.active = false;
+                            break;
+                        }
+                    }
+                }
+            }else if(delay>0){
+                delay--;
+                if(delay==0){
+                    core.awoken=true;
+                }
+            }
+            sidedRedstone.postSync(core,aBaseMetaTileEntity);
+        }
+    }
+
+    @Override
+    public boolean allowPullStack(IGregTechTileEntity iGregTechTileEntity, int i, byte b, ItemStack itemStack) {
+        return true;
+    }
+
+    @Override
+    public boolean allowPutStack(IGregTechTileEntity iGregTechTileEntity, int i, byte b, ItemStack itemStack) {
+        return true;
+    }
+
+    @Override
+    public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) {
+        if(aBaseMetaTileEntity.getWorld()==null){
+            if(aSide==aFacing){
+                return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][aColorIndex + 1], aActive ? READER_ONLINE : READER_OFFLINE};
+            }
+            return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][aColorIndex + 1]};
+        }
+        if(aSide==aBaseMetaTileEntity.getFrontFacing()){
+            return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][aColorIndex + 1], aActive ? READER_ONLINE : READER_OFFLINE};
+        }else if(aSide==aFacing){
+            return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][aColorIndex + 1], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_PIPE_OUT)};
+        }
+        return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][aColorIndex + 1]};
+    }
+
+    @Override
+    public ITexture[][][] getTextureSet(ITexture[] aTextures) {
+        return null;
+    }
+}
diff --git a/src/main/java/com/github/technus/tectech/thing/tileEntity/MicroControllerTileEntity.java b/src/main/java/com/github/technus/tectech/thing/tileEntity/MicroControllerTileEntity.java
deleted file mode 100644
index 3167bf820d..0000000000
--- a/src/main/java/com/github/technus/tectech/thing/tileEntity/MicroControllerTileEntity.java
+++ /dev/null
@@ -1,118 +0,0 @@
-package com.github.technus.tectech.thing.tileEntity;
-
-import com.github.technus.avrClone.AvrCore;
-import com.github.technus.avrClone.instructions.ExecutionEvent;
-import com.github.technus.avrClone.instructions.Instruction;
-import com.github.technus.avrClone.instructions.InstructionRegistry;
-import com.github.technus.avrClone.instructions.exceptions.DebugEvent;
-import com.github.technus.avrClone.instructions.exceptions.DelayEvent;
-import com.github.technus.avrClone.memory.EepromMemory;
-import com.github.technus.avrClone.memory.RemovableMemory;
-import com.github.technus.avrClone.memory.program.ProgramMemory;
-import com.github.technus.tectech.TecTech;
-import net.minecraft.nbt.NBTTagCompound;
-import net.minecraft.tileentity.TileEntity;
-
-public class MicroControllerTileEntity extends TileEntity {
-    static {
-        Instruction.random= TecTech.RANDOM;
-    }
-    private final AvrCore core;
-    private int[] tempData;
-    private boolean debugRun;
-    private int delay;
-
-    public MicroControllerTileEntity(){
-        core=new AvrCore();
-        core.setUsingImmersiveOperands(false);
-        core.setInstructionRegistry(InstructionRegistry.INSTRUCTION_REGISTRY_OP);
-        core.setDataMemory(1<<getBlockMetadata(),1<<getBlockMetadata());
-        core.setCpuRegisters(0x30);
-    }
-
-    @Override
-    public void readFromNBT(NBTTagCompound tag) {
-        super.readFromNBT(tag);
-        debugRun=tag.getBoolean("debugRun");
-        delay=tag.getInteger("delay");
-        core.active =tag.getBoolean("active");
-        core.awoken=(tag.getBoolean("awoken"));
-        core.programCounter=tag.getInteger("programCounter");
-        if(tag.hasKey("instructions")){
-            int[] instructions=tag.getIntArray("instructions");
-            int[] param0=tag.getIntArray("param0");
-            int[] param1=tag.getIntArray("param1");
-            core.setProgramMemory(new ProgramMemory(
-                    core.getInstructionRegistry(),core.isUsingImmersiveOperands(),
-                    instructions,param0,param1));
-        }
-        if(tag.hasKey("eepromSize")){
-            core.setEepromDefinition(EepromMemory.make(tag.getInteger("eepromSize")));
-        }
-        if(tag.hasKey("dataMemory")){
-            tempData=tag.getIntArray("dataMemory");
-        }
-        core.checkValid();
-    }
-
-    @Override
-    public void writeToNBT(NBTTagCompound tag) {
-        super.writeToNBT(tag);
-        tag.setBoolean("debugRun",debugRun);
-        tag.setInteger("delay",delay);
-        tag.setBoolean("active",core.active);
-        tag.setBoolean("awoken",core.awoken);
-        tag.setInteger("programCounter",core.programCounter);
-        ProgramMemory programMemory=core.getProgramMemory();
-        if(programMemory!=null){
-            tag.setIntArray("instructions",programMemory.instructions);
-            tag.setIntArray("param0",programMemory.param0);
-            tag.setIntArray("param1",programMemory.param1);
-        }
-        RemovableMemory<EepromMemory> eeprom=core.getEepromMemory();
-        if(eeprom!=null){
-            tag.setInteger("eepromSize",eeprom.getDefinition().getSize());
-        }
-        if(core.dataMemory!=null){
-            tag.setIntArray("dataMemory",core.dataMemory);
-        }
-    }
-
-    @Override
-    public void invalidate() {
-        super.invalidate();
-    }
-
-    @Override
-    public void updateEntity() {
-        super.updateEntity();
-        if (tempData != null) {
-            //todo discovery of components
-            core.dataMemory = tempData;
-            tempData = null;
-        }
-        if (core.active) {
-            core.interruptsHandle();
-            if (core.awoken) {
-                delay=0;
-                for (int i = 0, cycles = Math.min(1 << getBlockMetadata(), 512); i < cycles; i++) {
-                    ExecutionEvent executionEvent = core.cpuCycleForce();
-                    if (executionEvent != null) {
-                        if (executionEvent.throwable instanceof DelayEvent) {
-                            delay = executionEvent.data[0];
-                            break;
-                        } else if (debugRun && executionEvent.throwable instanceof DebugEvent) {
-                            core.active = false;
-                            break;
-                        }
-                    }
-                }
-            }else if(delay>0){
-                delay--;
-                if(delay==0){
-                    core.awoken=true;
-                }
-            }
-        }
-    }
-}
-- 
cgit