probably working avr core

3 files changed, 318 insertions, 19 deletions

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/tileEntity/MicroControllerTileEntity.java b/src/main/java/com/github/technus/tectech/thing/metaTileEntity/single/GT_MetaTileEntity_MicroControllerTileEntity.java
index 3167bf820d..6692c19cea 100644
--- a/src/main/java/com/github/technus/tectech/thing/tileEntity/MicroControllerTileEntity.java
+++ b/src/main/java/com/github/technus/tectech/thing/metaTileEntity/single/GT_MetaTileEntity_MicroControllerTileEntity.java
@@ -1,4 +1,4 @@
-package com.github.technus.tectech.thing.tileEntity;
+package com.github.technus.tectech.thing.metaTileEntity.single;
 
 import com.github.technus.avrClone.AvrCore;
 import com.github.technus.avrClone.instructions.ExecutionEvent;
@@ -10,29 +10,54 @@ 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 net.minecraft.tileentity.TileEntity;
 
-public class MicroControllerTileEntity extends TileEntity {
+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 final AvrCore core;
+    private AvrCore core;
     private int[] tempData;
     private boolean debugRun;
     private int delay;
 
-    public MicroControllerTileEntity(){
+    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<<getBlockMetadata(),1<<getBlockMetadata());
+        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 readFromNBT(NBTTagCompound tag) {
-        super.readFromNBT(tag);
+    public void loadNBTData(NBTTagCompound tag) {
         debugRun=tag.getBoolean("debugRun");
         delay=tag.getInteger("delay");
         core.active =tag.getBoolean("active");
@@ -56,8 +81,7 @@ public class MicroControllerTileEntity extends TileEntity {
     }
 
     @Override
-    public void writeToNBT(NBTTagCompound tag) {
-        super.writeToNBT(tag);
+    public void saveNBTData(NBTTagCompound tag) {
         tag.setBoolean("debugRun",debugRun);
         tag.setInteger("delay",delay);
         tag.setBoolean("active",core.active);
@@ -79,23 +103,18 @@ public class MicroControllerTileEntity extends TileEntity {
     }
 
     @Override
-    public void invalidate() {
-        super.invalidate();
-    }
-
-    @Override
-    public void updateEntity() {
-        super.updateEntity();
+    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 << getBlockMetadata(), 512); i < cycles; i++) {
+                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) {
@@ -113,6 +132,38 @@ public class MicroControllerTileEntity extends TileEntity {
                     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;
+    }
 }