Modificación de código para matriz

Conseguí un código para un juego de snake en un arduino mega, pero pasa que al hacerle las modificaciones y adaptarlo a mis necesidades, todo quedó invertido, es decir, los leds que no deben de estar encendidos, lo están y viceversa, (me aparece una serpiente apagada, y su comida un led apagado, el resto está encendido).
Mi matriz es de cátodo común según filas.
omití los transistores pnp.

// Pin connected to Pin 12 of 74HC595 (Latch)
int latchPin = 8;

// Pin connected to Pin 11 of 74HC595 (Clock)
int clockPin = 12;

// Pin connected to Pin 14 of 74HC595 (Data)
int dataPin = 11;

// Screen
byte led[8];
void loop() {

  snakeInit();
  screenUpdate();
  oldTimer = millis();
  curTimer = millis();

  while(!dead) {
    curTimer = millis();
    
    setDirection();
    
    if(curTimer-oldTimer >= 320) {
      curDirection = newDirection;
      moveSnake(curDirection);
      screenUpdate();
      oldTimer = millis();
    }
    
    // update screen
    screenDisplay();
  }
  
  int count = 0;
  while(count<8) {
    curTimer = millis();
    if(curTimer-oldTimer >= 100) {
      led[count]=B11111111;
      oldTimer = millis();
      count++;
    }
    screenDisplay();
  }
  
  clrscr();
  
  while(1) {
    curTimer = millis();
    if(curTimer-oldTimer >= 700) {
      for(int i=0; i<8; i++) {
        led[i]=~led[i];
      }
      oldTimer = millis();
    }
    screenDisplay();
  }
  
  
}
void clrscr(){
  for(int i=0; i<8; i++) {
    led[i] = B00000000;
  }
}
void screenUpdate() {
  Link * ptr;
  ptr = pTail;
  
  clrscr();
  while(ptr!=NULL) {
    led[ptr->y-1] = led[ptr->y-1] | (1<<(8-ptr->x));
    ptr = ptr->next;
  }
  
  led[appleY-1] = led[appleY-1] | (1<<(8-appleX));
}  
  
void screenDisplay() {
  byte row = B10000000;

  for (byte k = 0; k < 8; k++) {
    // Open up the latch ready to receive data
    digitalWrite(latchPin, LOW);
    
    shiftData(~row); // if use PNP transitors
    // shiftData(row);
    shiftData(~led[k]);
    // Close the latch, sending the data in the registers out to the matrix
    digitalWrite(latchPin, HIGH);
    row = row >> 1;
  }
}



void shiftData(byte data) {
  // Shift out 8 bits LSB first,
  // on rising edge of clock
  boolean pinState;

  //clear shift register read for sending data
  digitalWrite(dataPin, LOW);

  // for each bit in dataOut send out a bit
  for (int i=0; i<8; i++) 
  {
    //set clockPin to LOW prior to sending bit
    digitalWrite(clockPin, LOW);

    // if the value of data and (logical AND) a bitmask
    // are true, set pinState to 1 (HIGH)
    if (data & (1<<i)) 
    {
      pinState = HIGH;
    }
    else 
    {
      pinState = LOW;
    }

    //sets dataPin to HIGH or LOW depending on pinState
    digitalWrite(dataPin, pinState);

    //send bit out on rising edge of clock
    digitalWrite(clockPin, HIGH);
    digitalWrite(dataPin, LOW);
  }

  //stop shifting
  digitalWrite(clockPin, LOW);
}

¿Cómo podría resolver este problema?

usa un negador ! donde se controlan las cosas que estan saliendo invertidas y asunto solucionado. Aca lo tienes

 shiftData(~row); // if use PNP transitors
    // shiftData(row);
    shiftData(~led[k]);

Si omitiste los PNP parece que debes usar

shiftData(row);

la siguiente línea dice que bit se encienden, led[k]

Entonces, una linea controla, la fila, y la otra linea el bit y como se encienden. Si ahora tu problema es que se encienden invertidos, deberías quitar el ~led[k] y solo poner led[k] Has las pruebas