Initial gh-pages firmware hosting

2 files changed, 4204 insertions, 0 deletions

diff --git a/.pio/libdeps/esp32-s3-n16r8/U8g2/examples/games/LittleRookChess/LittleRookChess.ino b/.pio/libdeps/esp32-s3-n16r8/U8g2/examples/games/LittleRookChess/LittleRookChess.ino
new file mode 100644
index 0000000..3a4aca9
--- /dev/null
+++ b/.pio/libdeps/esp32-s3-n16r8/U8g2/examples/games/LittleRookChess/LittleRookChess.ino
@@ -0,0 +1,2347 @@
+/*
+
+  LittleRookChess.ino
+  
+  A Simple Chess Engine (ported from U8glib)
+
+  Universal 8bit Graphics Library (https://github.com/olikraus/u8g2/)
+
+  Copyright (c) 2016, olikraus@gmail.com
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without modification, 
+  are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice, this list 
+    of conditions and the following disclaimer.
+    
+  * Redistributions in binary form must reproduce the above copyright notice, this 
+    list of conditions and the following disclaimer in the documentation and/or other 
+    materials provided with the distribution.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 
+  CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, 
+  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
+  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
+  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 
+  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
+  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
+  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
+  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
+  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  
+
+  Current Rule Limitation
+    - no minor promotion, only "Queening" of the pawn
+    - threefold repetition is not detected (same board situation appears three times)
+	Note: Could be implemented, but requires tracking of the complete game
+    - Fifty-move rule is not checked (no pawn move, no capture within last 50 moves)
+	
+  Words
+    Ply		a half move
+    
+  General Links
+    http://chessprogramming.wikispaces.com/
+
+  Arduino specific
+    http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1260055596
+    
+  Prefixes  
+    chess_		Generic Chess Application Interface
+    ce_		Chess engine, used internally, these function should not be called directly
+    cu_		Chess utility function
+    stack_		Internal function for stack handling
+
+  Issues
+    10.01.2011
+      - castling to the right does not move the rook
+	  --> done
+      - castling to the left: King can only move two squares
+	  --> done
+      
+    11.01.2011	
+      Next Steps:
+	- replace stack_NextCurrentPos with cu_NextPos, cleanup code according to the loop variable
+	    --> done
+	- Castling: Need to check for fields under attack
+	    --> done
+	
+	- Check for WIN / LOOSE situation, perhaps call ce_Eval() once on the top-level board setup
+	    just after the real move
+	- cleanup cu_Move
+	    --> almost done
+	- add some heuristics to the eval procedure
+	- add right side menu
+	  --> done
+	- clean up chess_ManualMove
+	  --> done
+	- finish menu (consider is_game_end, undo move)
+        - end condition: if KING is under attack and if KING can not move to a field which is under attack...
+	      then the game is lost. What will be returned by the Eval procedure? is it -INF?
+	    --> finished
+	    
+	- reduce the use of variable color, all should be reduced to board_orientation and ply&1
+	
+	- chess_GetNextMarked shoud make use of cu_NextPos
+	    --> done
+	- chess_ManualMove: again cleanup, solve draw issue (KING is not in check and no legal moves are available)
+	    --> done
+    22.01.2011
+	- simplify eval_t ce_Eval(void)
+	- position eval does not work, still moves side pawn :-(
+	      maybe because all pieces are considered
+	    --> done
+
+    17. June 2016
+	U8g2/Arduboy Port
+*/
+
+#include <Arduino.h>
+#include <U8g2lib.h>
+
+#ifdef U8X8_HAVE_HW_SPI
+#include <SPI.h>
+#endif
+#ifdef U8X8_HAVE_HW_I2C
+#include <Wire.h>
+#endif
+
+
+/*
+  U8glib Example Overview:
+    Frame Buffer Examples: clearBuffer/sendBuffer. Fast, but may not work with all Arduino boards because of RAM consumption
+    Page Buffer Examples: firstPage/nextPage. Less RAM usage, should work with all Arduino boards.
+    U8x8 Text Only Example: No RAM usage, direct communication with display controller. No graphics, 8x8 Text only.
+    
+  This is a page buffer example.    
+*/
+
+void chess_Init(u8g2_t *u8g, uint8_t body_color);
+
+#define ARDUBOY
+//#define PI_SHIELD
+
+#ifdef ARDUBOY
+/*=== ARDUBOY Production, Kickstarter Edition ===*/
+U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 12, /* dc=*/ 4, /* reset=*/ 6);	// Arduboy (Production, Kickstarter Edition)
+void setup(void) {
+  //u8g2.begin(/*Select=*/ A0, /*Right/Next=*/ 5, /*Left/Prev=*/ 9, /*Up=*/ 8, /*Down=*/ 10, /*Home/Cancel=*/ A1); // Arduboy DevKit
+  u8g2.begin(/*Select=*/ 7, /*Right/Next=*/ A1, /*Left/Prev=*/ A2, /*Up=*/ A0, /*Down=*/ A3, /*Home/Cancel=*/ 8); // Arduboy 10 (Production)
+  chess_Init(u8g2.getU8g2(), 1);  /* assuming Arduboy OLED here, so make the body_color be 1 for the white OLED pixel */
+}
+#endif
+
+#ifdef PI_SHIELD
+/*=== Pax Instruments Shield ===*/
+U8G2_ST7567_PI_132X64_1_4W_HW_SPI u8g2(U8G2_R2, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
+void setup(void) {
+  u8g2.begin(/*Select=*/ 4, /*Right/Next=*/ 5, /*Left/Prev=*/ A1, /*Up=*/ U8X8_PIN_NONE, /*Down=*/ U8X8_PIN_NONE, /*Home/Cancel=*/ A2); // Pax Instrument Shield
+
+  /* U8g2 Project: Pax Instruments Shield: Enable Backlight */
+  pinMode(6, OUTPUT);
+  digitalWrite(6, 0);	
+
+  chess_Init(u8g2.getU8g2(), 0);  /* assuming Arduboy OLED here, so make the body_color be 1 for the white OLED pixel */
+}
+#endif
+
+/* Ignore PROGMEM for now */
+#define CHESS_PROGMEM
+#define chess_pgm_read(p) (*(p))
+#define CHESS_PSTR(s) (s)
+#define u8g2_DrawStrP u8g2_DrawStr
+
+/* backward compatibility */
+#define u8g2_SetDefaultBackgroundColor(u8g2) \
+  u8g2_SetDrawColor(u8g2, 0)
+#define u8g2_SetDefaultForegroundColor(u8g2) \
+  u8g2_SetDrawColor(u8g2, 1)
+
+
+/* menu button definitions: mapped to the u8g2 menu events */
+
+#define CHESS_KEY_NONE 0
+#define CHESS_KEY_NEXT U8X8_MSG_GPIO_MENU_NEXT
+#define CHESS_KEY_PREV U8X8_MSG_GPIO_MENU_PREV
+#define CHESS_KEY_SELECT U8X8_MSG_GPIO_MENU_SELECT
+#define CHESS_KEY_BACK U8X8_MSG_GPIO_MENU_HOME
+
+
+/*
+SAN identifies each piece by a single upper case letter.  The standard English
+values: pawn = "P", knight = "N", bishop = "B", rook = "R", queen = "Q", and
+king = "K".
+*/
+
+/* numbers for the various pieces */
+#define PIECE_NONE	0
+#define PIECE_PAWN 	1
+#define PIECE_KNIGHT  	2
+#define PIECE_BISHOP 	3
+#define PIECE_ROOK	4
+#define PIECE_QUEEN 	5
+#define PIECE_KING		6
+
+/* color definitions */
+#define COLOR_WHITE	0
+#define COLOR_BLACK	1
+
+/* a mask, which includes COLOR and PIECE number */
+#define COLOR_PIECE_MASK 0x01f
+
+#define CP_MARK_MASK 0x20
+
+#define ILLEGAL_POSITION 255
+
+/* This is the build in upper limit of the search stack */
+/* This value defines the amount of memory allocated for the search stack */
+/* The search depth of this chess engine can never exceed this value */
+#define STACK_MAX_SIZE 5
+
+/* chess half move stack: twice the number of undo's, a user can do */ 
+#define CHM_USER_SIZE 6
+
+/* the CHM_LIST_SIZE must be larger than the maximum search depth */
+/* the overall size of ste half move stack */
+#define CHM_LIST_SIZE (STACK_MAX_SIZE+CHM_USER_SIZE+2)
+
+typedef int16_t eval_t;	/* a variable type to store results from the evaluation */ 
+//#define EVAL_T_LOST -32768
+#define EVAL_T_MIN -32767
+#define EVAL_T_MAX 32767
+//#define EVAL_T_WIN 32767
+
+/* for maintainance of our own stack: this is the definition of one element on the stack */
+struct _stack_element_struct
+{
+  /* the current source position which is investigated */
+  uint8_t current_pos;
+  uint8_t current_cp;
+  uint8_t current_color;	/* COLOR_WHITE or COLOR_BLACK: must be predefines */
+  
+  /* the move which belongs to that value, both values are game positions */
+  uint8_t best_from_pos;
+  uint8_t best_to_pos;
+  /* the best value, which has been dicovered so far */
+  eval_t best_eval;
+};
+typedef struct _stack_element_struct stack_element_t;
+typedef struct _stack_element_struct *stack_element_p;
+
+/* chess half move history */
+struct _chm_struct
+{
+  uint8_t main_cp;		/* the main piece, which is moved */
+  uint8_t main_src;		/* the source position of the main piece */
+  uint8_t main_dest; 	/* the destination of the main piece */
+  
+  uint8_t other_cp;		/* another piece: the captured one, the ROOK in case of castling or PIECE_NONE */
+  uint8_t other_src;		/* the delete position of other_cp. Often identical to main_dest except for e.p. and castling */
+  uint8_t other_dest;		/* only used for castling: ROOK destination pos */
+  
+  /* the position of the last pawn, which did a double move forward */
+  /* this is required to check en passant conditions */
+  /* this array can be indexed by the color of the current player */
+  /* this is the condition BEFORE the move was done */
+  uint8_t pawn_dbl_move[2];
+  
+  /* flags for the movement of rook and king; required for castling */
+  /* a 1 means: castling is (still) possible */
+  /* a 0 means: castling not possible */
+  /*  bit 0 left side white */
+  /*  bit 1 right side white */
+  /*  bit 2 left side black */
+  /*  bit 3 right side black */
+  /* this is the condition BEFORE the move was done */
+  uint8_t castling_possible;   
+};
+
+typedef struct _chm_struct chm_t;
+typedef struct _chm_struct *chm_p;
+
+/* little rook chess, main structure */
+struct _lrc_struct
+{  
+  /* half-move (ply) counter: Counts the number of half-moves so far. Starts with 0 */
+  /* the lowest bit is used to derive the color of the current player */
+  /* will be set to zero in chess_SetupBoard() */
+  uint8_t ply_count;
+  
+  /* the half move stack position counter, counts the number of elements in chm_list */
+  uint8_t chm_pos;
+  
+  /* each element contains a colored piece, empty fields have value 0 */
+  /* the field with index 0 is black (lower left) */
+  uint8_t board[64];	
+  /* the position of the last pawn, which did a double move forward */
+  /* this is required to check en passant conditions */
+  /* this array can be indexed by the color of the current player */
+  uint8_t pawn_dbl_move[2]; 
+  
+  /* flags for the movement of rook and king; required for castling */
+  /* a 1 means: castling is (still) possible */
+  /* a 0 means: castling not possible */
+  /*  bit 0 left side white */
+  /*  bit 1 right side white */
+  /*  bit 2 left side black */
+  /*  bit 3 right side black */
+  uint8_t castling_possible; 
+  
+  /* board orientation */
+  /* 0: white is below COLOR_WHITE */
+  /* 1: black is below COLOR_BLACK */
+  /* bascially, this can be used as a color */
+  uint8_t orientation;
+  
+  /* exchange colors of the pieces */
+  /* 0: white has an empty body, use this for bright background color */
+  /* 1: black has an empty body, use this for dark backround color */
+  uint8_t strike_out_color;
+  
+  /* 0, when the game is ongoing */
+  /* 1, when the game is stopped (lost or draw) */
+  uint8_t is_game_end;
+  /* the color of the side which lost the game */
+  /* this value is only valid, when is_game_end is not 0 */
+  /* values 0 and 1 represent WHITE and BLACK, 2 means a draw */
+  uint8_t lost_side_color;
+  
+  
+  
+  /* checks are executed in ce_LoopRecur */
+  /* these checks will put some marks on the board */
+  /* this will be used by the interface to find out */
+  /* legal moves */
+  uint8_t check_src_pos;
+  uint8_t check_mode;		/* CHECK_MODE_NONE, CHECK_MODE_MOVEABLE, CHECK_MODE_TARGET_MOVE */
+  
+  
+  /* count of the attacking pieces, indexed by color */
+  uint8_t find_piece_cnt[2];
+
+  /* sum of the attacking pieces, indexed by color */
+  uint8_t find_piece_weight[2];
+
+  /* points to the current element of the search stack */
+  /* this stack is NEVER empty. The value 0 points to the first element of the stack */
+  /* actually "curr_depth" represent half-moves (plies) */
+  uint8_t curr_depth;
+  uint8_t max_depth;
+  stack_element_p curr_element;
+  
+  /* allocated memory for the search stack */
+  stack_element_t stack_memory[STACK_MAX_SIZE];
+
+  /* the half move stack, used for move undo and depth search, size is stored in chm_pos */
+  chm_t chm_list[CHM_LIST_SIZE];
+};
+typedef struct _lrc_struct lrc_t;
+
+#define CHECK_MODE_NONE 0
+#define CHECK_MODE_MOVEABLE 1
+#define CHECK_MODE_TARGET_MOVE 2
+
+
+
+/*==============================================================*/
+/* global variables */
+/*==============================================================*/
+
+lrc_t lrc_obj;
+u8g2_t *lrc_u8g;  /* pointer to the C object of u8g2 lib, this is used by the chess engine */
+
+
+/*==============================================================*/
+/* forward declarations */
+/*==============================================================*/
+
+/* 
+  apply no inline to some of the functions:
+  avr-gcc very often inlines functions, however not inline saves a lot of program memory!
+  On the other hand there are some really short procedures which should be inlined (like cp_GetColor)
+  These procedures are marked static to prevent the generation of the expanded procedure, which
+  also saves space.
+*/
+
+uint8_t stack_Push(uint8_t color) U8G2_NOINLINE;
+void stack_Pop(void) U8G2_NOINLINE;
+void stack_InitCurrElement(void) U8G2_NOINLINE;
+void stack_Init(uint8_t max) U8G2_NOINLINE;
+void stack_SetMove(eval_t val, uint8_t to_pos) U8G2_NOINLINE;
+uint8_t cu_NextPos(uint8_t pos) U8G2_NOINLINE;
+static uint8_t cu_gpos2bpos(uint8_t gpos);
+static uint8_t cp_Construct(uint8_t color, uint8_t piece);
+static uint8_t cp_GetPiece(uint8_t cp);
+static uint8_t cp_GetColor(uint8_t cp);
+uint8_t cp_GetFromBoard(uint8_t pos) U8G2_NOINLINE;
+void cp_SetOnBoard(uint8_t pos, uint8_t cp) U8G2_NOINLINE;
+
+void cu_ClearBoard(void) U8G2_NOINLINE;
+void chess_SetupBoard(void) U8G2_NOINLINE;
+eval_t ce_Eval(void);
+
+void cu_ClearMoveHistory(void) U8G2_NOINLINE;
+void cu_ReduceHistoryByFullMove(void) U8G2_NOINLINE;
+void cu_UndoHalfMove(void) U8G2_NOINLINE;
+chm_p cu_PushHalfMove(void) U8G2_NOINLINE;
+
+
+void ce_CalculatePositionWeight(uint8_t pos);
+uint8_t ce_GetPositionAttackWeight(uint8_t pos, uint8_t color);
+
+void chess_Thinking(void);
+void ce_LoopPieces(void);
+
+
+/*==============================================================*/
+/* search stack */
+/*==============================================================*/
+
+/* get current element from stack */
+struct _stack_element_struct *stack_GetCurrElement(void)
+{
+  return lrc_obj.curr_element;
+}
+
+uint8_t stack_Push(uint8_t color)
+{
+  if ( lrc_obj.curr_depth == lrc_obj.max_depth )
+    return 0;
+  lrc_obj.curr_depth++;
+  lrc_obj.curr_element = lrc_obj.stack_memory+lrc_obj.curr_depth;
+  
+  /* change view for the evaluation */
+  color ^= 1;
+  stack_GetCurrElement()->current_color = color;
+
+  return 1;
+}
+
+void stack_Pop(void)
+{
+  lrc_obj.curr_depth--;
+  lrc_obj.curr_element = lrc_obj.stack_memory+lrc_obj.curr_depth;
+}
+
+/* reset the current element on the stack */
+void stack_InitCurrElement(void)
+{
+  stack_element_p e = stack_GetCurrElement();
+  e->best_eval = EVAL_T_MIN;
+  e->best_from_pos = ILLEGAL_POSITION;
+  e->best_to_pos = ILLEGAL_POSITION;
+}
+
+/* resets the search stack (and the check mode) */
+void stack_Init(uint8_t max)
+{
+  lrc_obj.curr_depth = 0;
+  lrc_obj.curr_element = lrc_obj.stack_memory;
+  lrc_obj.max_depth = max;
+  lrc_obj.check_mode = CHECK_MODE_NONE;
+  stack_InitCurrElement();
+  stack_GetCurrElement()->current_color = lrc_obj.ply_count;
+  stack_GetCurrElement()->current_color &= 1;
+}
+
+/* assign evaluation value and store the move, if this is the best move */
+/* assumes, that current_pos contains the source position */
+void stack_SetMove(eval_t val, uint8_t to_pos)
+{
+  stack_element_p e = stack_GetCurrElement();
+  if ( e->best_eval < val )
+  {
+    e->best_eval = val;
+    e->best_from_pos = e->current_pos;
+    e->best_to_pos = to_pos;
+  }
+}
+
+/* 
+  calculate next position on a 0x88 board 
+  loop is constructed in this way:
+  i = 0;
+  do
+  {
+    ...
+    i = cu_NextPos(i);
+  } while( i != 0 );
+
+  next pos might be started with an illegal position like 255
+*/
+uint8_t cu_NextPos(uint8_t pos)
+{
+  /* calculate next gpos */
+  pos++;
+  if ( ( pos & 0x08 ) != 0 )
+  {
+    pos+= 0x10;
+    pos&= 0xf0; 
+  }
+  if ( ( pos & 0x80 ) != 0 )
+    pos = 0;
+  return pos;
+}
+
+uint8_t cu_PrevPos(uint8_t pos)
+{
+  /* calculate prev gpos */
+  pos--;
+  if ( ( pos & 0x80 ) != 0 )
+    pos = 0x077;
+  else if ( ( pos & 0x08 ) != 0 )
+  {
+    pos &= 0xf0; 
+    pos |= 0x07;
+  }
+  return pos;
+}
+
+
+/*==============================================================*/
+/* position transltion */
+/*==============================================================*/
+/*
+  there are two positions
+    1. game position (gpos): BCD encoded x-y values
+    2. board position (bpos): a number between 0 and 63, only used to access the board.
+*/
+/*
+  gpos:	game position value
+  returns:	board position
+  note:	does not do any checks
+*/
+static uint8_t cu_gpos2bpos(uint8_t gpos)
+{
+  uint8_t bpos = gpos;
+  bpos &= 0xf0;
+  bpos >>= 1;
+  gpos &= 0x0f;
+  bpos |= gpos;
+  return bpos;
+}
+
+#define gpos_IsIllegal(gpos) ((gpos) & 0x088)
+
+
+/*==============================================================*/
+/* colored piece handling */
+/*==============================================================*/
+
+#define cp_IsMarked(cp)  ((cp) & CP_MARK_MASK)
+
+
+/*
+  piece: one of PIECE_xxx
+  color: COLOR_WHITE or COLOR_BLACK
+
+  returns: A colored piece
+*/
+static uint8_t cp_Construct(uint8_t color, uint8_t piece)
+{
+  color <<= 4;
+  color |= piece;
+  return color;
+}
+
+/* inline is better than a macro */
+static uint8_t cp_GetPiece(uint8_t cp)
+{
+  cp &= 0x0f;
+  return cp;
+}
+
+/*
+  we could use a macro:
+  #define cp_GetColor(cp)	(((cp) >> 4)&1)
+  however, inlined functions are sometimes much better
+*/
+static uint8_t cp_GetColor(uint8_t cp)
+{
+  cp >>= 4;
+  cp &= 1;
+  return cp;
+}
+
+/*
+  pos: game position
+  returns the colored piece at the given position
+*/
+uint8_t cp_GetFromBoard(uint8_t pos)
+{
+  return lrc_obj.board[cu_gpos2bpos(pos)];
+}
+
+/*
+  pos: game position
+  cp: colored piece
+*/
+void cp_SetOnBoard(uint8_t pos, uint8_t cp)
+{
+  /*printf("cp_SetOnBoard gpos:%02x cp:%02x\n", pos, cp);*/
+  lrc_obj.board[cu_gpos2bpos(pos)] = cp;
+}
+
+/*==============================================================*/
+/* global board access */
+/*==============================================================*/
+
+void cu_ClearBoard(void)
+{
+  uint8_t i;
+  /* clear the board */
+  for( i = 0; i < 64; i++ )
+    lrc_obj.board[i] = PIECE_NONE;
+  
+  lrc_obj.ply_count = 0;
+  lrc_obj.orientation = COLOR_WHITE;
+  
+  lrc_obj.pawn_dbl_move[0] = ILLEGAL_POSITION;
+  lrc_obj.pawn_dbl_move[1] = ILLEGAL_POSITION;
+  
+  lrc_obj.castling_possible = 0x0f;
+  
+  lrc_obj.is_game_end = 0;
+  lrc_obj.lost_side_color = 0;
+
+  /* clear half move history */
+  cu_ClearMoveHistory();
+
+}
+
+/*
+  test setup
+  white wins in one move
+*/
+void chess_SetupBoardTest01(void)
+{
+  cu_ClearBoard();
+  lrc_obj.board[7+7*8] = cp_Construct(COLOR_BLACK, PIECE_KING);
+  lrc_obj.board[7+5*8] = cp_Construct(COLOR_WHITE, PIECE_PAWN);
+  lrc_obj.board[3] = cp_Construct(COLOR_WHITE, PIECE_KING);
+  lrc_obj.board[0+7*8] = cp_Construct(COLOR_BLACK, PIECE_ROOK);
+  lrc_obj.board[6] = cp_Construct(COLOR_WHITE, PIECE_QUEEN);
+} 
+
+/* setup the global board */
+void chess_SetupBoard(void)
+{
+  uint8_t i;
+  register uint8_t bp, wp;
+  
+  /* clear the board */
+  cu_ClearBoard();
+  
+  /* precronstruct pawns */
+  wp = cp_Construct(COLOR_WHITE, PIECE_PAWN);
+  bp = cp_Construct(COLOR_BLACK, PIECE_PAWN);
+  
+  /* setup pawn */
+  for( i = 0; i < 8; i++ )
+  {
+    lrc_obj.board[i+8] = wp;
+    lrc_obj.board[i+6*8] = bp;
+  }
+  
+  /* assign remaining pieces */
+  
+  lrc_obj.board[0] = cp_Construct(COLOR_WHITE, PIECE_ROOK);
+  lrc_obj.board[1] = cp_Construct(COLOR_WHITE, PIECE_KNIGHT);
+  lrc_obj.board[2] = cp_Construct(COLOR_WHITE, PIECE_BISHOP);
+  lrc_obj.board[3] = cp_Construct(COLOR_WHITE, PIECE_QUEEN);
+  lrc_obj.board[4] = cp_Construct(COLOR_WHITE, PIECE_KING);
+  lrc_obj.board[5] = cp_Construct(COLOR_WHITE, PIECE_BISHOP);
+  lrc_obj.board[6] = cp_Construct(COLOR_WHITE, PIECE_KNIGHT);
+  lrc_obj.board[7] = cp_Construct(COLOR_WHITE, PIECE_ROOK);
+
+  lrc_obj.board[0+7*8] = cp_Construct(COLOR_BLACK, PIECE_ROOK);
+  lrc_obj.board[1+7*8] = cp_Construct(COLOR_BLACK, PIECE_KNIGHT);
+  lrc_obj.board[2+7*8] = cp_Construct(COLOR_BLACK, PIECE_BISHOP);
+  lrc_obj.board[3+7*8] = cp_Construct(COLOR_BLACK, PIECE_QUEEN);
+  lrc_obj.board[4+7*8] = cp_Construct(COLOR_BLACK, PIECE_KING);
+  lrc_obj.board[5+7*8] = cp_Construct(COLOR_BLACK, PIECE_BISHOP);
+  lrc_obj.board[6+7*8] = cp_Construct(COLOR_BLACK, PIECE_KNIGHT);
+  lrc_obj.board[7+7*8] = cp_Construct(COLOR_BLACK, PIECE_ROOK);
+
+  //chess_SetupBoardTest01();
+
+}
+
+
+
+/*==============================================================*/
+/* checks */
+/*==============================================================*/
+
+/*
+  checks if the position is somehow illegal
+*/
+uint8_t cu_IsIllegalPosition(uint8_t pos, uint8_t my_color)
+{
+  uint8_t board_cp;
+  /* check, if the position is offboard */
+  if ( gpos_IsIllegal(pos) != 0 )
+    return 1;
+  /* get the piece from the board */
+  board_cp = cp_GetFromBoard(pos);
+  /* check if hit our own pieces */
+  if ( board_cp != 0 ) 
+    if ( cp_GetColor(board_cp) == my_color )
+      return 1;
+  /* all ok, we could go to this position */
+  return 0;
+}
+
+/*==============================================================*/
+/* evaluation procedure */
+/*==============================================================*/
+
+/*
+  basic idea is to return a value between EVAL_T_MIN and EVAL_T_MAX
+*/
+
+/*
+  the weight table uses the PIECE number as index:
+      #define PIECE_NONE	0
+      #define PIECE_PAWN 	1
+      #define PIECE_KNIGHT  	2
+      #define PIECE_BISHOP 	3
+      #define PIECE_ROOK	4
+      #define PIECE_QUEEN 	5
+      #define PIECE_KING		6
+  the king itself is not counted
+*/
+uint8_t ce_piece_weight[] = { 0, 1, 3, 3, 5, 9, 0 };
+uint8_t ce_pos_weight[] = { 0, 1, 1, 2, 2, 1, 1, 0};
+/*
+  evaluate the current situation on the global board
+*/
+eval_t ce_Eval(void)
+{
+  uint8_t cp;
+  uint8_t is_my_king_present = 0;
+  uint8_t is_opposit_king_present = 0;
+  eval_t material_my_color = 0;
+  eval_t material_opposit_color = 0;
+  eval_t position_my_color = 0;
+  eval_t position_opposit_color = 0;
+  eval_t result;
+  uint8_t pos;
+  
+  pos = 0;
+  do
+  {
+    /* get colored piece from the board */
+    cp = cp_GetFromBoard(pos);
+    
+    if ( cp_GetPiece(cp) != PIECE_NONE )
+    {
+      if ( stack_GetCurrElement()->current_color == cp_GetColor(cp) )
+      {
+	/* this is our color */
+	/* check if we found our king */
+	if ( cp_GetPiece(cp) == PIECE_KING  )
+	  is_my_king_present = 1;
+	material_my_color += ce_piece_weight[cp_GetPiece(cp)];
+	if ( cp_GetPiece(cp) == PIECE_PAWN || cp_GetPiece(cp) == PIECE_KNIGHT  )
+	{
+	  position_my_color += ce_pos_weight[pos&7]*ce_pos_weight[(pos>>4)&7];
+	}
+      }
+      else
+      {
+	/* this is the opposit color */
+	if ( cp_GetPiece(cp) == PIECE_KING  )
+	  is_opposit_king_present = 1;
+	material_opposit_color += ce_piece_weight[cp_GetPiece(cp)];
+	if ( cp_GetPiece(cp) == PIECE_PAWN || cp_GetPiece(cp) == PIECE_KNIGHT )
+	{
+	  position_opposit_color += ce_pos_weight[pos&7]*ce_pos_weight[(pos>>4)&7];
+	}
+      }
+    }
+    pos = cu_NextPos(pos);
+  } while( pos != 0 );
+
+    
+  /* decide if we lost or won the game */
+  if ( is_my_king_present == 0 )
+    return EVAL_T_MIN;	/*_LOST*/
+  if ( is_opposit_king_present == 0 )
+    return EVAL_T_MAX;	/*_WIN*/
+  
+  /* here is the evaluation function */
+  
+  result = material_my_color - material_opposit_color;
+  result <<= 3;
+  result += position_my_color - position_opposit_color;
+  return result;
+}
+
+/*==============================================================*/
+/* move backup and restore */
+/*==============================================================*/
+
+
+/* this procedure must be called to keep the size as low as possible */
+/* if the chm_list is large enough, it could hold the complete history */
+/* but for an embedded controler... it is deleted for every engine search */
+void cu_ClearMoveHistory(void)
+{
+  lrc_obj.chm_pos = 0;
+}
+
+void cu_ReduceHistoryByFullMove(void)
+{
+  uint8_t i;
+  while( lrc_obj.chm_pos > CHM_USER_SIZE )
+  {
+    i = 0;
+    for(;;)
+    {
+      if ( i+2 >= lrc_obj.chm_pos )
+	break;
+      lrc_obj.chm_list[i] = lrc_obj.chm_list[i+2];
+      i++;
+    }
+    lrc_obj.chm_pos -= 2;
+  }
+}
+
+void cu_UndoHalfMove(void)
+{
+  chm_p chm;
+  
+  if ( lrc_obj.chm_pos == 0 )
+    return;
+  
+  lrc_obj.chm_pos--;
+
+  chm = lrc_obj.chm_list+lrc_obj.chm_pos;
+  
+  lrc_obj.pawn_dbl_move[0] = chm->pawn_dbl_move[0];
+  lrc_obj.pawn_dbl_move[1] = chm->pawn_dbl_move[1];
+  lrc_obj.castling_possible = chm->castling_possible;
+  
+  cp_SetOnBoard(chm->main_src, chm->main_cp);
+  cp_SetOnBoard(chm->main_dest, PIECE_NONE);
+  
+  if ( chm->other_src != ILLEGAL_POSITION )
+    cp_SetOnBoard(chm->other_src, chm->other_cp);
+  if ( chm->other_dest != ILLEGAL_POSITION )
+    cp_SetOnBoard(chm->other_dest, PIECE_NONE);
+
+}
+
+/*
+  assumes, that the following members of the returned chm structure are filled 
+  uint8_t main_cp;		the main piece, which is moved
+  uint8_t main_src;		the source position of the main piece
+  uint8_t main_dest; 	the destination of the main piece
+  
+  uint8_t other_cp;		another piece: the captured one, the ROOK in case of castling or PIECE_NONE
+  uint8_t other_src;		the delete position of other_cp. Often identical to main_dest except for e.p. and castling
+  uint8_t other_dest;		only used for castling: ROOK destination pos
+
+*/
+chm_p cu_PushHalfMove(void)
+{
+  chm_p chm;
+  
+  chm = lrc_obj.chm_list+lrc_obj.chm_pos;
+  if ( lrc_obj.chm_pos < CHM_LIST_SIZE-1)
+    lrc_obj.chm_pos++;
+
+  chm->pawn_dbl_move[0] = lrc_obj.pawn_dbl_move[0];
+  chm->pawn_dbl_move[1] = lrc_obj.pawn_dbl_move[1];
+  chm->castling_possible = lrc_obj.castling_possible;
+  return chm;
+}
+
+
+char chess_piece_to_char[] = "NBRQK";
+
+/*
+  simple moves on empty field: 	Ka1-b2
+  capture moves:				Ka1xb2
+  castling:						0-0 or 0-0-0
+*/
+
+static void cu_add_pos(char *s, uint8_t pos) U8G2_NOINLINE;
+
+static void cu_add_pos(char *s, uint8_t pos)
+{
+  *s = pos;
+  *s &= 15;
+  *s += 'a';
+  s++;
+  *s = pos;
+  *s >>= 4;
+  *s += '1';
+}
+
+const char *cu_GetHalfMoveStr(uint8_t idx)
+{
+  chm_p chm;
+  static char buf[7];		/*Ka1-b2*/
+  char *p = buf;
+  chm = lrc_obj.chm_list+idx;
+  
+  if ( cp_GetPiece(chm->main_cp) != PIECE_NONE )
+  {
+    if ( cp_GetPiece(chm->main_cp) > PIECE_PAWN )
+    {
+      *p++ = chess_piece_to_char[cp_GetPiece(chm->main_cp)-2];
+    }
+    cu_add_pos(p, chm->main_src);
+    p+=2;
+    if ( cp_GetPiece(chm->other_cp) == PIECE_NONE )
+      *p++ = '-';
+    else
+      *p++ = 'x';
+    cu_add_pos(p, chm->main_dest);
+    p+=2;
+  }
+  *p = '\0';
+  return buf;
+}
+
+
+
+
+
+/*==============================================================*/
+/* move */
+/*==============================================================*/
+
+/*
+  Move a piece from source position to a destination on the board
+  This function
+    - does not perform any checking
+    - however it processes "en passant" and casteling
+    - backup the move and allow 1x undo
+  
+  2011-02-05: 
+    - fill pawn_dbl_move[] for double pawn moves
+	--> done
+    - Implement casteling 
+	--> done
+    - en passant
+	--> done
+    - pawn conversion/promotion
+	--> done
+    - half-move backup 
+	--> done
+    - cleanup everything, minimize variables
+	--> done
+*/
+
+void cu_Move(uint8_t src, uint8_t dest)
+{  
+  /* start backup structure */
+  chm_p chm = cu_PushHalfMove();
+
+  /* these are the values from the board at the positions, provided as arguments to this function */
+  uint8_t cp_src, cp_dest;
+  
+  /* Maybe a second position is cleared and one additional location is set */
+  uint8_t clr_pos2;
+  uint8_t set_pos2;
+  uint8_t set_cp2;
+  
+  /* get values from board */
+  cp_src = cp_GetFromBoard(src);
+  cp_dest = cp_GetFromBoard(dest);
+
+  /* fill backup structure */
+  
+  chm->main_cp = cp_src;
+  chm->main_src = src;
+  chm->main_dest = dest;
+  
+  chm->other_cp = cp_dest;		/* prepace capture backup */
+  chm->other_src = dest;
+  chm->other_dest = ILLEGAL_POSITION;
+  
+  /* setup results as far as possible with some suitable values */
+  
+  clr_pos2 = ILLEGAL_POSITION;	/* for en passant and castling, two positions might be cleared */
+  set_pos2 = ILLEGAL_POSITION;	/* only used for castling */
+  set_cp2 = PIECE_NONE;			/* ROOK for castling */
+  
+  /* check for PAWN */
+  if ( cp_GetPiece(cp_src) == PIECE_PAWN )
+  {
+    
+    /* double step: is the distance 2 rows */
+    if ( (src - dest == 32) || ( dest - src == 32 ) )
+    {
+      /* remember the destination position */
+      lrc_obj.pawn_dbl_move[cp_GetColor(cp_src)] = dest;
+    }
+    
+    /* check if the PAWN is able to promote */
+    else if ( (dest>>4) == 0 || (dest>>4) == 7 )
+    {
+      /* do simple "queening" */
+      cp_src &= ~PIECE_PAWN;
+      cp_src |= PIECE_QUEEN;
+    }
+    
+    /* is it en passant capture? */
+    /* check for side move */
+    else if ( ((src + dest) & 1) != 0 )
+    {
+      /* check, if target field is empty */
+      if (  cp_GetPiece(cp_dest) == PIECE_NONE )
+      {
+	/* this is en passant */
+	/* no further checking required, because legal moves are assumed here */
+	/* however... the captured pawn position must be valid */
+	clr_pos2 = lrc_obj.pawn_dbl_move[cp_GetColor(cp_src) ^ 1];
+	chm->other_src = clr_pos2;
+	chm->other_cp = cp_GetFromBoard(clr_pos2);
+      }
+    }    
+  }
+  
+  /* check for the KING */
+  else if ( cp_GetPiece(cp_src) == PIECE_KING )
+  {
+    /* disallow castling, if the KING has moved */
+    if ( cp_GetColor(cp_src) == COLOR_WHITE )
+    {
+      /* if white KING has moved, disallow castling for white */
+      lrc_obj.castling_possible &= 0x0c;
+    }
+    else
+    {
+      /* if black KING has moved, disallow castling for black */
+      lrc_obj.castling_possible &= 0x03;
+    }
+    
+    /* has it been castling to the left? */
+    if ( src - dest == 2 )
+    {
+      /* let the ROOK move to pos2 */
+      set_pos2 = src-1;
+      set_cp2 = cp_GetFromBoard(src-4);
+      
+      /* the ROOK must be cleared from the original position */
+      clr_pos2 = src-4;
+      
+      chm->other_cp = set_cp2;
+      chm->other_src = clr_pos2;
+      chm->other_dest = set_pos2;
+    }
+    
+    /* has it been castling to the right? */
+    else if ( dest - src == 2 )
+    {
+      /* let the ROOK move to pos2 */
+      set_pos2 = src+1;
+      set_cp2 = cp_GetFromBoard(src+3);
+      
+      /* the ROOK must be cleared from the original position */
+      clr_pos2 = src+3;
+      
+      chm->other_cp = set_cp2;
+      chm->other_src = clr_pos2;
+      chm->other_dest = set_pos2;
+      
+    }
+    
+  }
+  
+  /* check for the ROOK */
+  else if ( cp_GetPiece(cp_src) == PIECE_ROOK )
+  {
+    /* disallow white left castling */
+    if ( src == 0x00 )
+      lrc_obj.castling_possible &= ~0x01;
+    /* disallow white right castling */
+    if ( src == 0x07 )
+      lrc_obj.castling_possible &= ~0x02;
+    /* disallow black left castling */
+    if ( src == 0x70 )
+      lrc_obj.castling_possible &= ~0x04;
+    /* disallow black right castling */
+    if ( src == 0x77 )
+      lrc_obj.castling_possible &= ~0x08;
+  }
+  
+  
+  /* apply new board situation */
+  
+  cp_SetOnBoard(dest, cp_src);
+  
+  if ( set_pos2 != ILLEGAL_POSITION )
+    cp_SetOnBoard(set_pos2, set_cp2);
+  
+  cp_SetOnBoard(src, PIECE_NONE);
+  
+  if ( clr_pos2 != ILLEGAL_POSITION )
+    cp_SetOnBoard(clr_pos2, PIECE_NONE);
+  
+  
+}
+
+/*
+  this subprocedure decides for evaluation of the current board situation or further (deeper) investigation
+  Argument pos is the new target position if the current piece 
+
+*/
+uint8_t ce_LoopRecur(uint8_t pos)
+{
+  eval_t eval;
+  
+  /* 1. check if target position is occupied by the same player (my_color) */
+  /*     of if pos is somehow illegal or not valid */
+  if ( cu_IsIllegalPosition(pos, stack_GetCurrElement()->current_color) != 0 )
+    return 0;
+
+  /* 2. move piece to the specified position, capture opponent piece if required */
+  cu_Move(stack_GetCurrElement()->current_pos, pos);
+
+  
+  /* 3. */
+  /* if depth reached: evaluate */
+  /* else: go down next level */
+  /* no eval if there had been any valid half-moves, so the default value (MIN) will be returned. */
+  if ( stack_Push(stack_GetCurrElement()->current_color) == 0 )
+  {
+    eval = ce_Eval();
+  }
+  else
+  {
+    /* init the element, which has been pushed */
+    stack_InitCurrElement();
+    /* start over with ntext level */
+    ce_LoopPieces();
+    /* get the best move from opponents view, so invert the result */
+    eval = -stack_GetCurrElement()->best_eval;
+    stack_Pop();
+  }
+  
+  /* 4. store result */
+  stack_SetMove(eval, pos);
+  
+  /* 5. undo the move */
+  cu_UndoHalfMove();
+  
+  /* 6. check special modes */
+  /* the purpose of these checks is to mark special pieces and positions on the board */
+  /* these marks can be checked by the user interface to highlight special positions */
+  if ( lrc_obj.check_mode != 0 )
+  {
+    stack_element_p e = stack_GetCurrElement();
+    if ( lrc_obj.check_mode == CHECK_MODE_MOVEABLE )
+    {
+      cp_SetOnBoard(e->current_pos, e->current_cp | CP_MARK_MASK );
+    }
+    else if ( lrc_obj.check_mode == CHECK_MODE_TARGET_MOVE )
+    {
+      if ( e->current_pos == lrc_obj.check_src_pos )
+      {
+	cp_SetOnBoard(pos, cp_GetFromBoard(pos)  | CP_MARK_MASK );
+      }
+    }
+  }
+  return 1;
+}
+
+/*==============================================================*/
+/* move pieces which can move one or more steps into a direction */
+/*==============================================================*/
+
+/*
+  subprocedure to generate various target positions for some pieces
+  special cases are handled in the piece specific sub-procedure
+
+  Arguments:
+    d: a list of potential directions
+    is_multi_step: if the piece can only do one step (zero for KING and KNIGHT)
+*/
+static const uint8_t ce_dir_offset_rook[] CHESS_PROGMEM = { 1, 16, (uint8_t)-16, (uint8_t)-1, 0 };
+static const uint8_t ce_dir_offset_bishop[] CHESS_PROGMEM = { 15, 17, (uint8_t)-17, (uint8_t)-15, 0 };
+static const uint8_t ce_dir_offset_queen[] CHESS_PROGMEM = { 1, 16, (uint8_t)-16, (uint8_t)-1, 15, 17, (uint8_t)-17, (uint8_t)-15, 0 };
+static const uint8_t ce_dir_offset_knight[] CHESS_PROGMEM = {14, (uint8_t)-14, 18, (uint8_t)-18, 31, (uint8_t)-31, 33, (uint8_t)-33, 0};
+
+void ce_LoopDirsSingleMultiStep(const uint8_t *d, uint8_t is_multi_step)
+{
+  uint8_t loop_pos;
+  
+  /* with all directions */
+  for(;;)
+  {
+    if ( chess_pgm_read(d) == 0 )
+      break;
+    
+    /* start again from the initial position */
+    loop_pos = stack_GetCurrElement()->current_pos;
+    
+    /* check direction */
+    do
+    {
+      /* check next position into one direction */
+      loop_pos += chess_pgm_read(d);
+      
+      /*
+	go further to ce_LoopRecur()
+	0 will be returned if the target position is illegal or a piece of the own color
+	this is used to stop walking into one direction
+      */
+      if ( ce_LoopRecur(loop_pos) == 0 )
+	break;
+      
+      /* stop if we had hit another piece */
+      if ( cp_GetPiece(cp_GetFromBoard(loop_pos)) != PIECE_NONE )
+	break;
+    } while( is_multi_step );
+    d++;
+  }
+}
+
+void ce_LoopRook(void)
+{
+  ce_LoopDirsSingleMultiStep(ce_dir_offset_rook, 1);
+}
+
+void ce_LoopBishop(void)
+{
+  ce_LoopDirsSingleMultiStep(ce_dir_offset_bishop, 1);
+}
+
+void ce_LoopQueen(void)
+{
+  ce_LoopDirsSingleMultiStep(ce_dir_offset_queen, 1);
+}
+
+void ce_LoopKnight(void)
+{
+  ce_LoopDirsSingleMultiStep(ce_dir_offset_knight, 0);
+}
+
+
+
+/*==============================================================*/
+/* move king */
+/*==============================================================*/
+
+uint8_t cu_IsKingCastling(uint8_t mask, int8_t direction, uint8_t cnt) U8G2_NOINLINE;
+
+/*
+  checks, if the king can do castling
+
+  Arguments:
+    mask:		the bit-mask for the global "castling possible" flag
+    direction:	left castling: -1, right castling 1
+    cnt:		number of fields to be checked: 3 or 2
+*/
+uint8_t cu_IsKingCastling(uint8_t mask, int8_t direction, uint8_t cnt)
+{
+  uint8_t pos;
+  uint8_t opponent_color;
+  
+  /* check if the current board state allows castling */
+  if ( (lrc_obj.castling_possible & mask) == 0 )
+    return 0; 	/* castling not allowed */
+  
+  /* get the position of the KING, could be white or black king */
+  pos = stack_GetCurrElement()->current_pos;
+  
+  /* calculate the color of the opponent */
+  opponent_color = 1;
+  opponent_color -= stack_GetCurrElement()->current_color;
+  
+  /* if the KING itself is given check... */
+  if ( ce_GetPositionAttackWeight(pos, opponent_color) > 0 )
+    return 0;
+
+  
+  /* check if fields in the desired direction are emtpy */
+  for(;;)
+  {
+    /* go to the next field */
+    pos += direction;
+    /* check for a piece */
+    if ( cp_GetPiece(cp_GetFromBoard(pos)) != PIECE_NONE )
+      return 0;		/* castling not allowed */
+
+    /* if some of the fields are under attack */
+    if ( ce_GetPositionAttackWeight(pos, opponent_color) > 0 )
+      return 0;
+    
+    cnt--;
+    if ( cnt == 0 )
+      break;
+  }
+  return 1; /* castling allowed */
+}
+
+void ce_LoopKing(void)
+{
+  /*
+    there is an interessting timing problem in this procedure
+    it must be checked for castling first and as second step the normal
+    KING movement. If we would first check for normal moves, than
+    any marks might be overwritten by the ROOK in the case of castling.
+  */
+  
+  /* castling (this must be done before checking normal moves (see above) */
+  if ( stack_GetCurrElement()->current_color == COLOR_WHITE )
+  {
+    /* white left castling */
+    if ( cu_IsKingCastling(1, -1, 3) != 0 )
+    {
+      /* check for attacked fields */
+      ce_LoopRecur(stack_GetCurrElement()->current_pos-2);
+    }
+    /* white right castling */
+    if ( cu_IsKingCastling(2, 1, 2) != 0 )
+    {
+      /* check for attacked fields */
+      ce_LoopRecur(stack_GetCurrElement()->current_pos+2);
+    }
+  }
+  else
+  {
+    /* black left castling */
+    if ( cu_IsKingCastling(4, -1, 3) != 0 )
+    {
+      /* check for attacked fields */
+      ce_LoopRecur(stack_GetCurrElement()->current_pos-2);
+    }
+    /* black right castling */
+    if ( cu_IsKingCastling(8, 1, 2) != 0 )
+    {
+      /* check for attacked fields */
+      ce_LoopRecur(stack_GetCurrElement()->current_pos+2);
+    }
+  }
+  
+  /* reuse queen directions */
+  ce_LoopDirsSingleMultiStep(ce_dir_offset_queen, 0);
+}
+
+
+/*==============================================================*/
+/* move pawn */
+/*==============================================================*/
+
+/*
+  doppelschritt: nur von der grundlinie aus, beide (!) felder vor dem bauern m�ssen frei sein
+  en passant: nur unmittelbar nachdem ein doppelschritt ausgef�hrt wurde.
+*/
+void ce_LoopPawnSideCapture(uint8_t loop_pos)
+{
+  if ( gpos_IsIllegal(loop_pos) == 0 )
+  {
+    /* get the piece from the board */
+    /* if the field is NOT empty */
+    if ( cp_GetPiece(cp_GetFromBoard(loop_pos)) != PIECE_NONE )
+    {
+      /* normal capture */
+      ce_LoopRecur(loop_pos);
+      /* TODO: check for pawn conversion/promotion */
+    }
+    else
+    {
+      /* check conditions for en passant capture */
+      if ( stack_GetCurrElement()->current_color == COLOR_WHITE )
+      {
+	if ( lrc_obj.pawn_dbl_move[COLOR_BLACK]+16 == loop_pos )
+	{
+	  ce_LoopRecur(loop_pos);
+	  /* note: pawn conversion/promotion can not occur */
+	}
+      }
+      else
+      {
+	if ( lrc_obj.pawn_dbl_move[COLOR_WHITE] == loop_pos+16 )
+	{
+	  ce_LoopRecur(loop_pos);
+	  /* note: pawn conversion/promotion can not occur */
+	}
+      }
+    }
+  }
+}
+
+void ce_LoopPawn(void)
+{
+  uint8_t initial_pos = stack_GetCurrElement()->current_pos; 
+  uint8_t my_color = stack_GetCurrElement()->current_color;
+  
+  uint8_t loop_pos;
+  uint8_t line;
+  
+  /* one step forward */
+  
+  loop_pos = initial_pos;
+  line = initial_pos;
+  line >>= 4;
+  if ( my_color == COLOR_WHITE )
+    loop_pos += 16;
+  else
+    loop_pos -= 16;
+  if ( gpos_IsIllegal(loop_pos) == 0 )
+  {
+    /* if the field is empty */
+    if ( cp_GetPiece(cp_GetFromBoard(loop_pos)) == PIECE_NONE )
+    {
+      /* TODO: check for and loop through piece conversion/promotion */
+      ce_LoopRecur(loop_pos);      
+
+      /* second step forward */
+      
+      /* if pawn is on his starting line */
+      if ( (my_color == COLOR_WHITE && line == 1) || (my_color == COLOR_BLACK && line == 6 ) )
+      {
+	/* the place before the pawn is not occupied, so we can do double moves, see above */
+	
+	if ( my_color == COLOR_WHITE )
+	  loop_pos += 16;
+	else
+	  loop_pos -= 16;
+	if ( cp_GetPiece(cp_GetFromBoard(loop_pos)) == PIECE_NONE )
+	{
+	  /* this is a special case, other promotions of the pawn can not occur */
+	  ce_LoopRecur(loop_pos);
+	}
+      }
+    }
+  }
+
+  /* capture */
+  
+  loop_pos = initial_pos;
+  if ( my_color == COLOR_WHITE )
+    loop_pos += 15;
+  else
+    loop_pos -= 15;
+  ce_LoopPawnSideCapture(loop_pos);
+
+
+  loop_pos = initial_pos;
+  if ( my_color == COLOR_WHITE )
+    loop_pos += 17;
+  else
+    loop_pos -= 17;
+  ce_LoopPawnSideCapture(loop_pos);
+}
+
+/*==============================================================*/
+/* attacked */
+/*==============================================================*/
+
+/*
+  from a starting position, search for a piece, that might jump to that postion.
+  return:
+    the two global variables
+      lrc_obj.find_piece_weight[0];
+      lrc_obj.find_piece_weight[1];
+  will be increased by the weight of the attacked pieces of that color.
+  it is usually required to reset these global variables to zero, before using
+  this function.
+*/
+
+void ce_FindPieceByStep(uint8_t start_pos, uint8_t piece, const uint8_t *d, uint8_t is_multi_step)
+{
+  uint8_t loop_pos, cp;
+  
+  /* with all directions */
+  for(;;)
+  {
+    if ( chess_pgm_read(d) == 0 )
+      break;
+    
+    /* start again from the initial position */
+    loop_pos = start_pos;
+    
+    /* check direction */
+    do
+    {
+      /* check next position into one direction */
+      loop_pos += chess_pgm_read(d);
+      
+      /* check if the board boundary has been crossed */
+      if ( (loop_pos & 0x088) != 0 )
+	break;
+      
+      /* get the colored piece from the board */
+      cp = cp_GetFromBoard(loop_pos);
+      
+      /* stop if we had hit another piece */
+      if ( cp_GetPiece(cp) != PIECE_NONE )
+      {
+	/* if it is the piece we are looking for, then add the weight */
+	if ( cp_GetPiece(cp) == piece )
+	{
+	  lrc_obj.find_piece_weight[cp_GetColor(cp)] += ce_piece_weight[piece];
+	  lrc_obj.find_piece_cnt[cp_GetColor(cp)]++;
+	}
+	/* in any case, break out of the inner loop */
+	break;
+      }
+    } while( is_multi_step );
+    d++;
+  }
+}
+
+void ce_FindPawnPiece(uint8_t dest_pos, uint8_t color)
+{
+  uint8_t cp;
+  /* check if the board boundary has been crossed */
+  if ( (dest_pos & 0x088) == 0 )
+  {
+    /* get the colored piece from the board */
+    cp = cp_GetFromBoard(dest_pos);
+    /* only if there is a pawn of the matching color */
+    if ( cp_GetPiece(cp) == PIECE_PAWN )
+    {
+      if ( cp_GetColor(cp) == color )
+      {
+	/* the weight of the PAWN */
+	lrc_obj.find_piece_weight[color] += 1;
+	lrc_obj.find_piece_cnt[color]++;
+      }
+    }
+  }
+}
+
+
+/*
+  find out, which pieces do attack a specified field
+  used to
+  - check if the KING can do castling
+  - check if the KING must move
+
+  may be used in the eval procedure ... once...
+
+  the result is stored in the global array
+    uint8_t lrc_obj.find_piece_weight[2];
+  which is indexed with the color.
+  lrc_obj.find_piece_weight[COLOR_WHITE] is the sum of all white pieces
+  which can directly move to this field.
+
+  example:
+    if the black KING is at "pos" and lrc_obj.find_piece_weight[COLOR_WHITE] is not zero 
+    (after executing ce_CalculatePositionWeight(pos)) then the KING must be protected or moveed, because 
+    the KING was given check.
+*/
+
+void ce_CalculatePositionWeight(uint8_t pos)
+{
+  
+  lrc_obj.find_piece_weight[0] = 0;
+  lrc_obj.find_piece_weight[1] = 0;
+  lrc_obj.find_piece_cnt[0] = 0;
+  lrc_obj.find_piece_cnt[1] = 0;
+  
+  if ( (pos & 0x088) != 0 )
+    return;
+
+  ce_FindPieceByStep(pos, PIECE_ROOK, ce_dir_offset_rook, 1);
+  ce_FindPieceByStep(pos, PIECE_BISHOP, ce_dir_offset_bishop, 1);
+  ce_FindPieceByStep(pos, PIECE_QUEEN, ce_dir_offset_queen, 1);
+  ce_FindPieceByStep(pos, PIECE_KNIGHT, ce_dir_offset_knight, 0);
+  ce_FindPieceByStep(pos, PIECE_KING, ce_dir_offset_queen, 0);
+
+  ce_FindPawnPiece(pos+17, COLOR_BLACK);
+  ce_FindPawnPiece(pos+15, COLOR_BLACK);
+  ce_FindPawnPiece(pos-17, COLOR_WHITE);
+  ce_FindPawnPiece(pos-15, COLOR_WHITE);
+}
+
+/*
+  calculate the summed weight of pieces with specified color which can move to a specified position
+
+  argument:
+    pos: 	the position which should be analysed
+    color: 	the color of those pieces which should be analysed
+		e.g. if a black piece is at 'pos' and 'color' is white then this procedure returns the white atting count
+*/
+uint8_t ce_GetPositionAttackWeight(uint8_t pos, uint8_t color)
+{
+  ce_CalculatePositionWeight(pos);
+  return lrc_obj.find_piece_weight[color];
+}
+
+uint8_t ce_GetPositionAttackCount(uint8_t pos, uint8_t color)
+{
+  ce_CalculatePositionWeight(pos);
+  return lrc_obj.find_piece_cnt[color];
+}
+
+
+/*==============================================================*/
+/* depth search starts here: loop over all pieces of the current color on the board */
+/*==============================================================*/
+
+void ce_LoopPieces(void)
+{
+  stack_element_p e = stack_GetCurrElement();
+  /* start with lower left position (A1) */
+  e->current_pos = 0;
+  do
+  {
+    e->current_cp = cp_GetFromBoard(e->current_pos);
+    /* check if the position on the board is empty */
+    if ( e->current_cp != 0 )
+    {
+      /* only generate moves for the current color */
+      if ( e->current_color == cp_GetColor(e->current_cp) )
+      {
+	chess_Thinking();
+	
+	/* find out which piece is used */
+	switch(cp_GetPiece(e->current_cp))
+	{
+	  case PIECE_NONE:
+	    break;
+	  case PIECE_PAWN:
+	    ce_LoopPawn();
+	    break;
+	  case PIECE_KNIGHT:
+	    ce_LoopKnight();
+	    break;
+	  case PIECE_BISHOP:
+	    ce_LoopBishop();
+	    break;
+	  case PIECE_ROOK:
+	    ce_LoopRook();
+	    break;
+	  case PIECE_QUEEN:
+	    ce_LoopQueen();
+	    break;
+	  case PIECE_KING:
+	    ce_LoopKing();
+	    break;
+	}
+      }
+    }    
+    e->current_pos = cu_NextPos(e->current_pos);
+  } while( e->current_pos != 0 );
+}
+
+/*==============================================================*/
+/* user interface */
+/*==============================================================*/
+
+/*
+eval_t chess_EvalCurrBoard(uint8_t color)
+{
+  stack_Init(0);
+  stack_GetCurrElement()->current_color = color;
+  ce_LoopPieces();
+  return stack_GetCurrElement()->best_eval;
+}
+*/
+
+/* clear any marks on the board */
+void chess_ClearMarks(void)
+{
+  uint8_t i;
+  for( i = 0; i < 64; i++ )
+     lrc_obj.board[i] &= ~CP_MARK_MASK;
+}
+
+/*
+  Mark all pieces which can do moves. This is done by setting flags on the global board
+*/
+void chess_MarkMovable(void)
+{
+  stack_Init(0);
+  //stack_GetCurrElement()->current_color = color;
+  lrc_obj.check_mode = CHECK_MODE_MOVEABLE;
+  ce_LoopPieces();
+}
+
+/*
+  Checks, if the piece can move from src_pos to dest_pos
+
+  src_pos: The game position of a piece on the chess board
+*/
+void chess_MarkTargetMoves(uint8_t src_pos)
+{
+  stack_Init(0);
+  stack_GetCurrElement()->current_color = cp_GetColor(cp_GetFromBoard(src_pos));
+  lrc_obj.check_src_pos = src_pos;
+  lrc_obj.check_mode = CHECK_MODE_TARGET_MOVE;  
+  ce_LoopPieces();
+}
+
+/*
+  first call should start with 255
+  this procedure will return 255 if 
+      - there are no marks at all
+      - it has looped over all marks once
+*/
+uint8_t chess_GetNextMarked(uint8_t arg, uint8_t is_prev)
+{
+  uint8_t i;
+  uint8_t pos = arg;
+  for(i = 0; i < 64; i++)
+  {
+    if ( is_prev != 0 )
+      pos = cu_PrevPos(pos);
+    else
+      pos = cu_NextPos(pos);
+    if ( arg != 255 && pos == 0 )
+      return 255;
+    if ( cp_IsMarked(cp_GetFromBoard(pos)) )
+      return pos;
+  }
+  return 255;
+}
+
+
+/* make a manual move: this is a little bit more than cu_Move() */
+void chess_ManualMove(uint8_t src, uint8_t dest)
+{
+  uint8_t cp;
+  
+  /* printf("chess_ManualMove %02x -> %02x\n", src, dest); */
+  
+  /* if all other things fail, this is the place where the game is to be decided: */
+  /* ... if the KING is captured */
+  cp = cp_GetFromBoard(dest);
+  if ( cp_GetPiece(cp) == PIECE_KING )
+  {
+    lrc_obj.is_game_end = 1;
+    lrc_obj.lost_side_color = cp_GetColor(cp);    
+  }
+
+  /* clear ply history here, to avoid memory overflow */
+  /* may be the last X moves can be kept here */
+  cu_ReduceHistoryByFullMove();
+  /* perform the move on the board */
+  cu_Move(src, dest);
+  
+  /* update en passant double move positions: en passant position is removed after two half moves  */
+  lrc_obj.pawn_dbl_move[lrc_obj.ply_count&1]  = ILLEGAL_POSITION;
+  
+  /* update the global half move counter */
+  lrc_obj.ply_count++;
+
+
+  /* make a small check about the end of the game */
+  /* use at least depth 1, because we must know if the king can still move */
+  /* this is: King moves at level 0 and will be captured at level 1 */
+  /* so we check if the king can move and will not be captured at search level 1 */
+  
+  stack_Init(1);
+  ce_LoopPieces(); 
+
+  /* printf("chess_ManualMove/analysis best_from_pos %02x -> best_to_pos %02x\n", stack_GetCurrElement()->best_from_pos, stack_GetCurrElement()->best_to_pos); */
+
+  /* analyse the eval result */
+  
+  /* check if the other player has any moves left */
+  if ( stack_GetCurrElement()->best_from_pos == ILLEGAL_POSITION )
+  {
+    uint8_t color;
+    /* conditions: */
+    /* 1. no King, should never happen, opposite color has won */
+    /*		this is already checked above at the beginning if this procedure */
+    /* 2. King is under attack, opposite color has won */
+    /* 3. King is not under attack, game is a draw */
+
+    uint8_t i = 0;
+    color = lrc_obj.ply_count;
+    color &= 1;
+    do
+    {
+      cp = cp_GetFromBoard(i);
+      /* look for the King */
+      if ( cp_GetPiece(cp) == PIECE_KING )
+      {
+	if ( cp_GetColor(cp) == color )
+	{
+	  /* check if  KING is attacked */
+	  if ( ce_GetPositionAttackCount(i, color^1) != 0 )
+	  {
+	    /* KING is under attack (check) and can not move: Game is lost */
+	    lrc_obj.is_game_end = 1;
+	    lrc_obj.lost_side_color = color; 
+	  }
+	  else
+	  {
+	    /* KING is NOT under attack (check) but can not move: Game is a draw */
+	    lrc_obj.is_game_end = 1;
+	    lrc_obj.lost_side_color = 2; 
+	  }
+	  /* break out of the loop */
+	  break;	  
+	}
+      }
+      i = cu_NextPos(i);
+    } while( i != 0 );
+  }
+}
+
+/* let the computer do a move */
+void chess_ComputerMove(uint8_t depth)
+{
+  stack_Init(depth);
+  
+  //stack_GetCurrElement()->current_color = lrc_obj.ply_count;
+  //stack_GetCurrElement()->current_color &= 1;
+  
+  cu_ReduceHistoryByFullMove();
+  ce_LoopPieces();
+
+  chess_ManualMove(stack_GetCurrElement()->best_from_pos, stack_GetCurrElement()->best_to_pos);
+}
+
+
+/*==============================================================*/
+/* unix code */
+/*==============================================================*/
+
+#ifdef UNIX_MAIN
+
+#else
+
+/*==============================================================*/
+/* display menu */
+/*==============================================================*/
+
+extern const uint8_t chess_pieces_body_bm[] CHESS_PROGMEM; // forward decl
+extern const uint8_t chess_black_pieces_bm[] CHESS_PROGMEM; // forward decl 
+
+// uint8_t chess_key_code = 0;  // obsolete, u8g2 does proper debouncing
+uint8_t chess_key_cmd = 0;
+#define CHESS_STATE_MENU 0
+#define CHESS_STATE_SELECT_START 1
+#define CHESS_STATE_SELECT_PIECE 2
+#define CHESS_STATE_SELECT_TARGET_POS 3
+#define CHESS_STATE_THINKING 4
+#define CHESS_STATE_GAME_END 5
+uint8_t chess_state = CHESS_STATE_MENU;
+uint8_t chess_source_pos = 255;
+uint8_t chess_target_pos = 255;
+
+#define MNU_FONT u8g2_font_5x8_tr
+#define MNU_ENTRY_HEIGHT 9
+
+const char *mnu_title = "Little Rook Chess";
+const char *mnu_list[] = { "New Game (White)", "New Game (Black)", "Undo Move", "Return" };
+uint8_t mnu_pos = 0;
+uint8_t mnu_max = 4;
+
+void mnu_DrawHome(uint8_t is_highlight)
+{
+  uint8_t x = lrc_u8g->width - 35;  
+  uint8_t y = (lrc_u8g->height-1);
+  uint8_t t;
+  
+  u8g2_SetFont(lrc_u8g, u8g2_font_5x7_tr);
+  u8g2_SetDefaultForegroundColor(lrc_u8g);
+  if ( chess_state == CHESS_STATE_THINKING )
+     u8g2_DrawBitmap(lrc_u8g, x, y-8, 1, 8, chess_black_pieces_bm+24);
+  else
+  {     
+    t = u8g2_DrawStrP(lrc_u8g, x, y -1, CHESS_PSTR("Options"));
+      
+    if ( is_highlight )
+      u8g2_DrawFrame(lrc_u8g, x-1, y - MNU_ENTRY_HEIGHT +1, t, MNU_ENTRY_HEIGHT);  
+  }
+}
+
+void mnu_DrawEntry(uint8_t y, const char *str, uint8_t is_clr_background, uint8_t is_highlight)
+{
+  uint8_t t, x;
+  u8g2_SetFont(lrc_u8g, MNU_FONT);
+  t = u8g2_GetStrWidth(lrc_u8g, str);
+  x = u8g2_GetDisplayWidth(lrc_u8g);
+  x -= t;
+  x >>= 1;
+  
+  if ( is_clr_background )
+  {
+    u8g2_SetDefaultBackgroundColor(lrc_u8g);
+    u8g2_DrawBox(lrc_u8g, x-3, (lrc_u8g->height-1) - (y+MNU_ENTRY_HEIGHT-1+2), t+5, MNU_ENTRY_HEIGHT+4);
+  }
+  
+  u8g2_SetDefaultForegroundColor(lrc_u8g);
+  u8g2_DrawStr(lrc_u8g, x, (lrc_u8g->height-1) - y, str);
+  
+  if ( is_highlight )
+  {
+    u8g2_DrawFrame(lrc_u8g, 0, (lrc_u8g->height-1) - y -MNU_ENTRY_HEIGHT +1, u8g2_GetDisplayWidth(lrc_u8g), MNU_ENTRY_HEIGHT);
+  }
+}
+
+void mnu_Draw(void)
+{
+  uint8_t i;
+  uint8_t t,y;
+  /* calculate hight of the complete menu */
+  y = mnu_max;
+  y++; 					/* consider also some space for the title */
+  y++; 					/* consider also some space for the title */
+  y *= MNU_ENTRY_HEIGHT;
+  
+  /* calculate how much space will be left */
+  t = u8g2_GetDisplayHeight(lrc_u8g);			
+  t -= y;
+  
+  /* topmost pos start half of that empty space from the top */
+  t >>= 1;
+  y = u8g2_GetDisplayHeight(lrc_u8g);
+  y -= t;
+  
+  y -= MNU_ENTRY_HEIGHT;
+  mnu_DrawEntry(y, mnu_title, 0, 0);
+  
+  y -= MNU_ENTRY_HEIGHT;
+  
+
+  u8g2_DrawBitmap(lrc_u8g, 0, 1, 1, 8, chess_black_pieces_bm+24);
+  u8g2_DrawBitmap(lrc_u8g, 128-8, 1, 1, 8, chess_black_pieces_bm+24);
+
+  
+  for( i = 0; i < mnu_max; i++ )
+  {
+    y -= MNU_ENTRY_HEIGHT;
+    mnu_DrawEntry(y, mnu_list[i], 0, i == mnu_pos);
+  }
+}
+
+void mnu_Step(uint8_t key_cmd)
+{
+    if ( key_cmd == CHESS_KEY_NEXT )
+    {
+      if ( mnu_pos+1 < mnu_max )
+	mnu_pos++;
+    }
+    else if ( key_cmd == CHESS_KEY_PREV )
+    {
+      if ( mnu_pos > 0 )
+	mnu_pos--;
+    }
+}
+
+
+
+
+
+
+
+const uint8_t chess_pieces_body_bm[] CHESS_PROGMEM = 
+{
+  /* PAWN */ 		0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, /* 0x00, 0x00, 0x00, 0x0c, 0x0c, 0x00, 0x00, 0x00, */ 
+  /* KNIGHT */		0x00, 0x00, 0x1c, 0x2c, 0x04, 0x04, 0x0e, 0x00,
+  /* BISHOP */		0x00, 0x00, 0x1c, 0x1c, 0x1c, 0x08, 0x00, 0x00, /* 0x00, 0x00, 0x08, 0x1c, 0x1c, 0x08, 0x00, 0x00, */
+  /* ROOK */		0x00, 0x00, 0x00, 0x1c, 0x1c, 0x1c, 0x1c, 0x00,
+  /* QUEEN */		0x00, 0x00, 0x14, 0x1c, 0x08, 0x1c, 0x08, 0x00,
+  /* KING */		0x00, 0x00, 0x00, 0x08, 0x3e, 0x1c, 0x08, 0x00,
+};
+
+#ifdef NOT_REQUIRED
+/* white pieces are constructed by painting black pieces and cutting out the white area */
+const uint8_t chess_white_pieces_bm[] CHESS_PROGMEM = 
+{
+  /* PAWN */ 		0x00, 0x00, 0x0c, 0x12, 0x12, 0x0c, 0x1e, 0x00, 
+  /* KNIGHT */		0x00, 0x1c, 0x22, 0x52, 0x6a, 0x0a, 0x11, 0x1f,
+  /* BISHOP */		0x00, 0x08, 0x14, 0x22, 0x22, 0x14, 0x08, 0x7f,
+  /* ROOK */		0x00, 0x55, 0x7f, 0x22, 0x22, 0x22, 0x22, 0x7f,
+  /* QUEEN */		0x00, 0x55, 0x2a, 0x22, 0x14, 0x22, 0x14, 0x7f,
+  /* KING */		0x08, 0x1c, 0x49, 0x77, 0x41, 0x22, 0x14, 0x7f,
+};
+#endif
+
+const uint8_t chess_black_pieces_bm[] CHESS_PROGMEM = 
+{
+  /* PAWN */ 		0x00, 0x00, 0x18, 0x3c, 0x3c, 0x18, 0x3c, 0x00, /* 0x00, 0x00, 0x0c, 0x1e, 0x1e, 0x0c, 0x1e, 0x00, */ 
+  /* KNIGHT */		0x00, 0x1c, 0x3e, 0x7e, 0x6e, 0x0e, 0x1f, 0x1f,
+  /* BISHOP */		0x00, 0x1c, 0x2e, 0x3e, 0x3e, 0x1c, 0x08, 0x7f,  /*0x00, 0x08, 0x1c, 0x3e, 0x3e, 0x1c, 0x08, 0x7f,*/
+  /* ROOK */		0x00, 0x55, 0x7f, 0x3e, 0x3e, 0x3e, 0x3e, 0x7f,
+  /* QUEEN */		0x00, 0x55, 0x3e, 0x3e, 0x1c, 0x3e, 0x1c, 0x7f,
+  /* KING -*/		0x08, 0x1c, 0x49, 0x7f, 0x7f, 0x3e, 0x1c, 0x7f,
+};
+
+
+#if defined(DOGXL160_HW_GR)
+#define BOXSIZE 13
+#define BOXOFFSET 3
+#else
+#define BOXSIZE 8
+#define BOXOFFSET 1
+#endif
+
+u8g2_uint_t chess_low_edge;
+uint8_t chess_boxsize = 8;
+uint8_t chess_boxoffset = 1;
+
+
+void chess_DrawFrame(uint8_t pos, uint8_t is_bold)
+{
+  u8g2_uint_t x0, y0;
+
+  x0 = pos;
+  x0 &= 15;
+  if ( lrc_obj.orientation != COLOR_WHITE )
+    x0 ^= 7;
+
+  y0 = pos;
+  y0>>= 4;
+  if ( lrc_obj.orientation != COLOR_WHITE )
+    y0 ^= 7;
+  
+  x0 *= chess_boxsize;
+  y0 *= chess_boxsize;
+  
+  u8g2_SetDefaultForegroundColor(lrc_u8g);
+  u8g2_DrawFrame(lrc_u8g, x0, chess_low_edge - y0 - chess_boxsize+1, chess_boxsize, chess_boxsize);
+  
+  
+  if ( is_bold )
+  {
+      x0--;
+      y0++;
+  
+    u8g2_DrawFrame(lrc_u8g, x0, chess_low_edge - y0 - chess_boxsize +1, chess_boxsize+2, chess_boxsize+2);
+  }
+}
+
+
+void chess_DrawBoard(void)
+{
+  uint8_t i, j, cp;
+  const uint8_t *ptr;  /* pointer into CHESS_PROGMEM */
+
+  {
+    uint8_t x_offset = 1;
+    u8g2_SetDefaultForegroundColor(lrc_u8g);  
+    for( i = 0; i < 8*8; i+=8 )
+    {
+      for( j = 0; j < 8*8; j+=8 )
+      {
+        if ( ((i^j) & 8)  == 0 )
+        {
+          if ( lrc_obj.orientation == COLOR_WHITE )
+          {
+            cp =  lrc_obj.board[i+j/8];
+          }
+          else
+          {
+            cp =  lrc_obj.board[(7-i/8)*8+7-j/8];
+          }
+          if ( cp_GetPiece(cp) == PIECE_NONE )
+          {
+            u8g2_DrawPixel(lrc_u8g, j+0+x_offset, chess_low_edge - i-0);
+            u8g2_DrawPixel(lrc_u8g, j+0+x_offset, chess_low_edge - i-2);
+            u8g2_DrawPixel(lrc_u8g, j+0+x_offset, chess_low_edge - i-4);
+            u8g2_DrawPixel(lrc_u8g, j+0+x_offset, chess_low_edge - i-6);
+            u8g2_DrawPixel(lrc_u8g, j+2+x_offset, chess_low_edge - i-0);
+            u8g2_DrawPixel(lrc_u8g, j+2+x_offset, chess_low_edge - i-6);
+            u8g2_DrawPixel(lrc_u8g, j+4+x_offset, chess_low_edge - i-0);
+            u8g2_DrawPixel(lrc_u8g, j+4+x_offset, chess_low_edge - i-6);
+            u8g2_DrawPixel(lrc_u8g, j+6+x_offset, chess_low_edge - i-0);
+            u8g2_DrawPixel(lrc_u8g, j+6+x_offset, chess_low_edge - i-2);
+            u8g2_DrawPixel(lrc_u8g, j+6+x_offset, chess_low_edge - i-4);
+            u8g2_DrawPixel(lrc_u8g, j+6+x_offset, chess_low_edge - i-6);
+          }
+        }
+      }
+    }
+  }
+  
+  for ( i = 0; i < 8; i++ )
+  {
+    for ( j = 0; j < 8; j++ )
+    {
+      /* get piece from global board */
+      if ( lrc_obj.orientation == COLOR_WHITE )
+      {
+        cp =  lrc_obj.board[i*8+j];
+      }
+      else
+      {
+        cp =  lrc_obj.board[(7-i)*8+7-j];
+      }
+      if ( cp_GetPiece(cp) != PIECE_NONE )
+      {
+      	ptr = chess_black_pieces_bm;
+	      ptr += (cp_GetPiece(cp)-1)*8;
+       
+        u8g2_SetDefaultForegroundColor(lrc_u8g);
+        u8g2_DrawBitmap(lrc_u8g, j*chess_boxsize+chess_boxoffset-1, chess_low_edge - (i*chess_boxsize+chess_boxsize-chess_boxoffset), 1, 8, ptr);
+
+      	if ( cp_GetColor(cp) == lrc_obj.strike_out_color ) 
+      	{
+      	  ptr = chess_pieces_body_bm;
+      	  ptr += (cp_GetPiece(cp)-1)*8;
+          u8g2_SetDefaultBackgroundColor(lrc_u8g);
+          u8g2_DrawBitmap(lrc_u8g, j*chess_boxsize+chess_boxoffset-1, chess_low_edge - (i*chess_boxsize+chess_boxsize-chess_boxoffset), 1, 8, ptr);
+      	}
+      }
+    }
+  }
+  u8g2_SetDefaultForegroundColor(lrc_u8g);
+  
+  if ( (chess_source_pos & 0x88) == 0 )
+  {
+    chess_DrawFrame(chess_source_pos, 1);
+  }
+
+  if ( (chess_target_pos & 0x88) == 0 )
+  {
+    chess_DrawFrame(chess_target_pos, 0);
+  }
+  
+}
+
+
+void chess_Thinking(void)
+{
+}
+
+void chess_Init(u8g2_t *u8g, uint8_t body_color)
+{
+  lrc_u8g = u8g;
+
+  chess_low_edge = u8g2_GetDisplayHeight(lrc_u8g);
+  chess_low_edge--;
+  u8g2_SetBitmapMode(u8g, 1);		// restore previous behaviour
+
+  {
+  
+    chess_boxsize = 8;
+    chess_boxoffset = 1;
+  }
+  
+  
+    
+  lrc_obj.strike_out_color = body_color;
+  chess_SetupBoard();
+}
+
+
+
+void chess_Draw(void)
+{
+  if ( chess_state == CHESS_STATE_MENU )
+  {
+    if ( lrc_obj.ply_count == 0)
+      mnu_max = 2;
+    else
+      mnu_max = 4;
+    mnu_Draw();
+  }
+  else
+  {
+    chess_DrawBoard();
+    
+    {
+      uint8_t i;
+      uint8_t entries = lrc_obj.chm_pos;
+      if ( entries > 4 )
+      	entries = 4;
+      
+      u8g2_SetFont(lrc_u8g, u8g2_font_5x7_tr);
+      u8g2_SetDefaultForegroundColor(lrc_u8g);
+      for( i = 0; i < entries; i++ )
+      {
+        
+        u8g2_DrawStr(lrc_u8g, u8g2_GetDisplayWidth(lrc_u8g)-35, 8*(i+1), cu_GetHalfMoveStr(lrc_obj.chm_pos-entries+i));
+
+      }
+      
+    }
+    
+    if ( chess_state == CHESS_STATE_SELECT_PIECE )
+      mnu_DrawHome(chess_source_pos == 255);
+    else if ( chess_state == CHESS_STATE_SELECT_TARGET_POS )
+      mnu_DrawHome(chess_target_pos == 255);
+    else
+      mnu_DrawHome(0);
+      
+    if ( chess_state == CHESS_STATE_GAME_END )
+    {
+      switch( lrc_obj.lost_side_color )
+      {
+	case COLOR_WHITE:
+	  mnu_DrawEntry(u8g2_GetDisplayHeight(lrc_u8g) / 2-2, "Black wins", 1, 1);
+	  break;
+	case COLOR_BLACK:
+	  mnu_DrawEntry(u8g2_GetDisplayHeight(lrc_u8g) / 2-2, "White wins", 1, 1);
+	  break;
+	default:
+	  mnu_DrawEntry(u8g2_GetDisplayHeight(lrc_u8g) / 2-2, "Stalemate", 1, 1);
+	  break;
+      }  
+    }
+  }
+}
+
+
+void chess_Step(uint8_t keycode)
+{
+  chess_key_cmd = keycode;
+  
+  /*
+  if ( keycode == CHESS_KEY_NONE )
+  {
+    chess_key_cmd = chess_key_code;
+    chess_key_code = CHESS_KEY_NONE;
+  }
+  else
+  {
+    chess_key_cmd = CHESS_KEY_NONE;
+    chess_key_code = keycode;
+  }
+  */
+  //chess_ComputerMove(2);
+  switch(chess_state)
+  {
+    case CHESS_STATE_MENU:
+      mnu_Step(chess_key_cmd);
+      if ( chess_key_cmd == CHESS_KEY_SELECT )
+      {
+	if ( mnu_pos == 0 )
+	{
+          chess_SetupBoard();
+	  lrc_obj.orientation = 0;
+	  chess_state = CHESS_STATE_SELECT_START;
+	}
+	else if ( mnu_pos == 1 )
+	{
+          chess_SetupBoard();
+	  lrc_obj.orientation = 1;
+	  chess_state = CHESS_STATE_THINKING;
+	}
+	else if ( mnu_pos == 2 )
+	{
+	  if ( lrc_obj.ply_count >= 2 )
+	  {
+	    cu_UndoHalfMove();
+	    cu_UndoHalfMove();
+	    lrc_obj.ply_count-=2;
+	    if ( lrc_obj.ply_count == 0 )
+	      mnu_pos = 0;
+	  }
+	  chess_state = CHESS_STATE_SELECT_START;
+	}
+	else if ( mnu_pos == 3 )
+	{
+	  chess_state = CHESS_STATE_SELECT_START;
+	}
+      }
+      break;
+    case CHESS_STATE_SELECT_START:
+      chess_ClearMarks();
+      chess_MarkMovable();
+      chess_source_pos = chess_GetNextMarked(255, 0);
+      chess_target_pos = ILLEGAL_POSITION;
+      chess_state = CHESS_STATE_SELECT_PIECE;
+      break;
+      
+    case CHESS_STATE_SELECT_PIECE:
+      if ( chess_key_cmd == CHESS_KEY_NEXT )
+      {
+      	chess_source_pos = chess_GetNextMarked(chess_source_pos, lrc_obj.orientation);
+      }
+      else if ( chess_key_cmd == CHESS_KEY_PREV )
+      {
+      	chess_source_pos = chess_GetNextMarked(chess_source_pos, 1-lrc_obj.orientation );
+      }
+      else if ( chess_key_cmd == CHESS_KEY_SELECT )
+      {
+	if ( chess_source_pos == 255 )
+	{
+	  chess_state = CHESS_STATE_MENU;
+	}
+	else
+	{
+	  chess_ClearMarks();
+	  chess_MarkTargetMoves(chess_source_pos);
+	  chess_target_pos = chess_GetNextMarked(255, 0);
+	  chess_state = CHESS_STATE_SELECT_TARGET_POS;      
+	}
+      }
+      break;
+    case CHESS_STATE_SELECT_TARGET_POS:
+      if ( chess_key_cmd == CHESS_KEY_NEXT )
+      {
+      	chess_target_pos = chess_GetNextMarked(chess_target_pos, lrc_obj.orientation);
+	if ( chess_target_pos == 255 )
+	  chess_target_pos = chess_GetNextMarked(chess_target_pos, lrc_obj.orientation);
+      }
+      else if ( chess_key_cmd == CHESS_KEY_PREV )
+      {
+      	chess_target_pos = chess_GetNextMarked(chess_target_pos, 1-lrc_obj.orientation);
+	if ( chess_target_pos == 255 )
+	  chess_target_pos = chess_GetNextMarked(chess_target_pos, 1-lrc_obj.orientation);
+      }
+      else if ( chess_key_cmd == CHESS_KEY_BACK )
+      {
+      	chess_ClearMarks();
+      	chess_MarkMovable();
+      	chess_target_pos = ILLEGAL_POSITION;
+      	chess_state = CHESS_STATE_SELECT_PIECE;
+      }
+      else if ( chess_key_cmd == CHESS_KEY_SELECT )
+      {
+	chess_ManualMove(chess_source_pos, chess_target_pos);
+	if ( lrc_obj.is_game_end != 0 )
+	  chess_state = CHESS_STATE_GAME_END;
+	else
+	  chess_state = CHESS_STATE_THINKING;
+	/* clear marks as some kind of feedback to the user... it simply looks better */
+	chess_source_pos = ILLEGAL_POSITION;
+	chess_target_pos = ILLEGAL_POSITION;
+	chess_ClearMarks();
+      }
+      break;
+    case CHESS_STATE_THINKING:
+      chess_ComputerMove(2);
+      if ( lrc_obj.is_game_end != 0 )
+	chess_state = CHESS_STATE_GAME_END;
+      else
+	chess_state = CHESS_STATE_SELECT_START;
+	//chess_state = CHESS_STATE_THINKING
+      break;
+    case CHESS_STATE_GAME_END:
+      if ( chess_key_cmd != CHESS_KEY_NONE )
+      {
+	chess_state = CHESS_STATE_MENU;  
+	chess_SetupBoard();
+      }	
+      break;
+  }
+  
+}
+
+#endif	/* UNIX_MAIN */
+
+void loop(void) {
+  static uint8_t keycode = 0;
+  
+  u8g2.firstPage();
+  do {
+    chess_Draw();
+    if ( keycode == 0 )
+      keycode = u8g2.getMenuEvent();
+  } while ( u8g2.nextPage() );
+
+  if ( keycode == 0 )
+    keycode = u8g2.getMenuEvent();
+
+  if ( keycode == U8X8_MSG_GPIO_MENU_DOWN )
+    keycode = CHESS_KEY_NEXT;
+  if ( keycode == U8X8_MSG_GPIO_MENU_UP )
+    keycode = CHESS_KEY_PREV;
+  //if ( keycode == U8X8_MSG_GPIO_MENU_HOME )
+  //  keycode = CHESS_KEY_SELECT;
+      
+  chess_Step(keycode);
+  keycode = 0;
+  delay(1);
+}
+
diff --git a/.pio/libdeps/esp32-s3-n16r8/U8g2/examples/games/SpaceTrash/SpaceTrash.ino b/.pio/libdeps/esp32-s3-n16r8/U8g2/examples/games/SpaceTrash/SpaceTrash.ino
new file mode 100644
index 0000000..621c70b
--- /dev/null
+++ b/.pio/libdeps/esp32-s3-n16r8/U8g2/examples/games/SpaceTrash/SpaceTrash.ino
@@ -0,0 +1,1857 @@
+/*
+
+  SpaceTrash.ino
+
+  Universal 8bit Graphics Library (https://github.com/olikraus/u8g2/)
+
+  Copyright (c) 2016, olikraus@gmail.com
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without modification, 
+  are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice, this list 
+    of conditions and the following disclaimer.
+    
+  * Redistributions in binary form must reproduce the above copyright notice, this 
+    list of conditions and the following disclaimer in the documentation and/or other 
+    materials provided with the distribution.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 
+  CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, 
+  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
+  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
+  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 
+  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
+  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
+  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
+  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
+  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  
+
+*/
+
+#include <Arduino.h>
+#include <U8g2lib.h>
+
+#ifdef U8X8_HAVE_HW_SPI
+#include <SPI.h>
+#endif
+#ifdef U8X8_HAVE_HW_I2C
+#include <Wire.h>
+#endif
+
+// Please UNCOMMENT one of the contructor lines below
+// U8g2 Contructor List (Picture Loop Page Buffer)
+// The complete list is available here: https://github.com/olikraus/u8g2/wiki/u8g2setupcpp
+// Please update the pin numbers according to your setup. Use U8X8_PIN_NONE if the reset pin is not connected
+//U8G2_NULL u8g2(U8G2_R0);	// null device, a 8x8 pixel display which does nothing
+//U8G2_SSD1306_128X64_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 12, /* dc=*/ 4, /* reset=*/ 6);	// Arduboy (Production, Kickstarter Edition)
+//U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SSD1306_128X64_NONAME_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
+//U8G2_SSD1306_128X64_NONAME_1_3W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* reset=*/ 8);
+//U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
+//U8G2_SSD1306_128X64_ALT0_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // same as the NONAME variant, but may solve the "every 2nd line skipped" problem
+//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* reset=*/ 8);
+//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // All Boards without Reset of the Display
+//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 16, /* data=*/ 17, /* reset=*/ U8X8_PIN_NONE);   // ESP32 Thing, pure SW emulated I2C
+//U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ 16, /* data=*/ 17);   // ESP32 Thing, HW I2C with pin remapping
+//U8G2_SSD1306_128X64_NONAME_1_6800 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
+//U8G2_SSD1306_128X64_NONAME_1_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
+//U8G2_SSD1306_128X64_VCOMH0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but maximizes setContrast() range
+//U8G2_SSD1306_128X64_ALT0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but may solve the "every 2nd line skipped" problem
+//U8G2_SSD1306_102X64_EA_OLEDS102_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but may solve the "every 2nd line skipped" problem
+//U8G2_SSD1312_128X64_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SSD1312_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ 8);
+//U8G2_SSD1312_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
+//U8G2_SSD1312_120X28_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SSD1312_120X28_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ 8);
+//U8G2_SSD1312_120X28_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
+//U8G2_SH1106_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SH1106_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
+//U8G2_SH1106_128X64_VCOMH0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but maximizes setContrast() range
+//U8G2_SH1106_128X64_WINSTAR_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but uses updated SH1106 init sequence
+//U8G2_SH1106_128X32_VISIONOX_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
+//U8G2_SH1106_128X32_VISIONOX_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SH1106_72X40_WISE_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SH1107_64X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SH1107_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SH1107_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
+//U8G2_SH1107_128X80_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
+//U8G2_SH1107_PIMORONI_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);
+//U8G2_SH1107_SEEED_128X128_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);
+//U8G2_SH1107_SEEED_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
+//U8G2_SH1107_SEEED_96X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SH1107_HJR_OEL1M0201_96X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SH1107_TK078F288_80X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SH1108_128X160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_CH1120_128X160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SH1108_160X160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SH1122_256X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Enable U8G2_16BIT in u8g2.h
+//U8G2_SH1122_256X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);        // Enable U8G2_16BIT in u8g2.h
+//U8G2_SSD1306_128X32_UNIVISION_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 21, /* data=*/ 20, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather M0 Basic Proto + FeatherWing OLED
+//U8G2_SSD1306_128X32_UNIVISION_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather ESP8266/32u4 Boards + FeatherWing OLED
+//U8G2_SSD1306_128X32_UNIVISION_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // Adafruit ESP8266/32u4/ARM Boards + FeatherWing OLED
+//U8G2_SSD1306_128X32_UNIVISION_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
+//U8G2_SSD1306_128X32_WINSTAR_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
+//U8G2_SSD1306_64X48_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.66" OLED breakout board, Uno: A4=SDA, A5=SCL, 5V powered
+//U8G2_SSD1306_48X64_WINSTAR_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   
+//U8G2_SSD1306_64X32_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
+//U8G2_SSD1306_64X32_1F_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
+//U8G2_SSD1306_96X16_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.69" OLED 
+//U8G2_SSD1306_72X40_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.42" OLED 
+//U8G2_SSD1306_96X40_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
+//U8G2_SSD1306_96X39_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
+//U8G2_SSD1322_240X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SSD1322_TOPWIN_240X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SSD1322_NHD_256X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
+//U8G2_SSD1322_NHD_256X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
+//U8G2_SSD1322_ZJY_256X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
+//U8G2_SSD1322_ZJY_256X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
+//U8G2_SSD1362_256X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
+//U8G2_SSD1362_256X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
+//U8G2_SSD1362_206X36_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SSD1362_206X36_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SSD1363_256X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
+//U8G2_SSD1363_256X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
+//U8G2_SSD1322_NHD_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SSD1322_NHD_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SSD1325_NHD_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SSD1325_NHD_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SSD0323_OS128064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SSD0323_OS128064_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SSD1326_ER_256X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);         // experimental driver for ER-OLED018-1
+//U8G2_SSD1327_SEEED_96X96_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
+//U8G2_SSD1327_SEEED_96X96_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
+//U8G2_SSD1327_EA_W128128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SSD1327_EA_W128128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SSD1327_EA_W128128_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 5, /* data=*/ 4, /* reset=*/ U8X8_PIN_NONE);
+//U8G2_SSD1327_EA_W128128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); /* Uno: A4=SDA, A5=SCL, add "u8g2.setBusClock(400000);" into setup() for speedup if possible */
+//U8G2_SSD1327_MIDAS_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SSD1327_MIDAS_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SSD1327_MIDAS_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); /* Uno: A4=SDA, A5=SCL, add "u8g2.setBusClock(400000);" into setup() for speedup if possible */
+//U8G2_SSD1327_ZJY_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SSD1327_ZJY_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SSD1327_ZJY_128X128_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); /* Uno: A4=SDA, A5=SCL, add "u8g2.setBusClock(400000);" into setup() for speedup if possible */
+//U8G2_SSD1327_WS_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SSD1327_WS_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SSD1327_VISIONOX_128X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SSD1327_VISIONOX_128X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SSD1329_128X96_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SSD1329_128X96_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SSD1329_96X96_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SSD1329_96X96_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SSD1329_96X96_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ A4, /* dc=*/ A2, /* reset=*/ U8X8_PIN_NONE); //  Adafruit Feather 32u4 Basic Proto
+//U8G2_SSD1305_128X32_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SSD1305_128X32_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SSD1305_128X32_ADAFRUIT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SSD1305_128X32_ADAFRUIT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SSD1305_128X64_ADAFRUIT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SSD1305_128X64_ADAFRUIT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SSD1305_128X64_RAYSTAR_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SSD1305_128X64_RAYSTAR_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_SSD1309_128X64_NONAME0_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
+//U8G2_SSD1309_128X64_NONAME0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
+//U8G2_SSD1309_128X128_NONAME0_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
+//U8G2_SSD1309_128X128_NONAME0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
+//U8G2_SSD1309_128X64_NONAME2_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
+//U8G2_SSD1309_128X64_NONAME2_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
+//U8G2_SSD1316_128X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
+//U8G2_SSD1316_128X32_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	
+//U8G2_SSD1316_96X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
+//U8G2_SSD1316_96X32_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	
+//U8G2_SSD1317_96X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // not tested, not confirmed
+//U8G2_SSD1317_96X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	// not tested, not confirmed
+//U8G2_SSD1318_128X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
+//U8G2_SSD1318_128X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	
+//U8G2_SSD1320_160X132_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
+//U8G2_SSD1320_160X132_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	
+//U8G2_SSD1320_160X80_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
+//U8G2_SSD1320_160X80_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	
+//U8G2_SSD1320_128X72_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
+//U8G2_SSD1320_128X72_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 	
+//U8G2_LD7032_60X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 9, /* dc=*/ 10, /* reset=*/ 8);	// SW SPI Nano Board
+//U8G2_LD7032_60X32_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* reset=*/ U8X8_PIN_NONE);	// NOT TESTED!
+//U8G2_LD7032_60X32_ALT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 9, /* dc=*/ 10, /* reset=*/ 8);	// SW SPI Nano Board
+//U8G2_LD7032_60X32_ALT_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* reset=*/ U8X8_PIN_NONE);	// NOT TESTED!
+//U8G2_LD7032_128X36_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 9, /* dc=*/ 10, /* reset=*/ 8);	// SW SPI Nano Board
+//U8G2_LD7032_128X36_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* reset=*/ U8X8_PIN_NONE);	// NOT TESTED!
+//U8G2_UC1701_EA_DOGS102_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_UC1701_EA_DOGS102_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_PCD8544_84X48_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Nokia 5110 Display
+//U8G2_PCD8544_84X48_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);						// Nokia 5110 Display
+//U8G2_PCF8812_96X65_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Could be also PCF8814
+//U8G2_PCF8812_96X65_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);						// Could be also PCF8814
+//U8G2_PCF8812_101X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Could be also PCF8814
+//U8G2_PCF8812_101X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);						// Could be also PCF8814
+//U8G2_HX1230_96X68_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
+//U8G2_HX1230_96X68_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_KS0108_128X64_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ U8X8_PIN_NONE, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
+//U8G2_KS0108_ERM19264_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ 16, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
+//U8G2_HD44102_100X64_1 u8g2(U8G2_R0, 4, 5, 6, 7, 8, 9, 10, 11, /*enable=*/ 2, /*dc=*/ 3, /*cs0=*/ A0, /*cs1=*/ A1, /*cs2=*/ A2, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
+//U8G2_T7932_150X32_1 u8g2(U8G2_R0, 4, 5, 6, 7, 8, 9, 10, 11, /*enable=*/ 2, /*dc=*/ 3, /*cs0=*/ A0, /*cs1=*/ A1, /*cs2=*/ A2, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
+//U8G2_ST7920_256X32_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ U8X8_PIN_NONE, /*dc=*/ 17, /*reset=*/ U8X8_PIN_NONE);
+//U8G2_ST7920_256X32_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
+//U8G2_ST7920_192X32_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ U8X8_PIN_NONE, /*dc=*/ 17, /*reset=*/ U8X8_PIN_NONE);
+//U8G2_ST7920_192X32_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
+//U8G2_ST7920_128X32_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ U8X8_PIN_NONE, /*dc=*/ 17, /*reset=*/ U8X8_PIN_NONE);
+//U8G2_ST7920_128X32_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
+//U8G2_ST7920_144X32_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ U8X8_PIN_NONE, /*dc=*/ 17, /*reset=*/ U8X8_PIN_NONE);
+//U8G2_ST7920_144X32_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
+//U8G2_ST7920_160X32_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ U8X8_PIN_NONE, /*dc=*/ 17, /*reset=*/ U8X8_PIN_NONE);
+//U8G2_ST7920_160X32_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
+//U8G2_ST7920_128X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18 /* A4 */, /*cs=*/ U8X8_PIN_NONE, /*dc/rs=*/ 17 /* A3 */, /*reset=*/ 15 /* A1 */);	// Remember to set R/W to 0 
+//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
+//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* CS=*/ 10, /* reset=*/ 8);
+//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 14, /* data=*/ 13, /* CS=*/ 15, /* reset=*/ 16); // Feather HUZZAH ESP8266, E=clock=14, RW=data=13, RS=CS
+//U8G2_ST7920_128X64_1_HW_SPI u8g2(U8G2_R0, /* CS=*/ 10, /* reset=*/ 8);
+//U8G2_ST7920_128X64_1_HW_SPI u8g2(U8G2_R0, /* CS=*/ 15, /* reset=*/ 16); // Feather HUZZAH ESP8266, E=clock=14, RW=data=13, RS=CS
+//U8G2_ST7528_ERC16064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST7528_ERC16064_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST7539_192X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST7539_192X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST7565_EA_DOGM128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST7565_EA_DOGM128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST7565_64128N_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST7565_64128N_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST7565_EA_DOGM132_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
+//U8G2_ST7565_EA_DOGM132_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
+//U8G2_ST7565_ZOLEN_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST7565_ZOLEN_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST7565_LM6059_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Adafruit ST7565 GLCD
+//U8G2_ST7565_LM6059_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);			// Adafruit ST7565 GLCD
+//U8G2_ST7565_KS0713_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// KS0713 controller
+//U8G2_ST7565_KS0713_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);			// KS0713 controller
+//U8G2_ST7565_LX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST7565_LX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST7565_ERC12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST7565_ERC12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST7565_ERC12864_ALT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // contrast improved version for ERC12864
+//U8G2_ST7565_ERC12864_ALT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); // contrast improved version for ERC12864
+//U8G2_ST7565_NHD_C12832_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST7565_NHD_C12832_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST7565_NHD_C12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST7565_NHD_C12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST7565_JLX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST7565_JLX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST7567_PI_132X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
+//U8G2_ST7567_PI_132X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
+//U8G2_ST7567_JLX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
+//U8G2_ST7567_JLX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
+//U8G2_ST7567_122X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
+//U8G2_ST7567_122X32_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
+//U8G2_ST7567_OS12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
+//U8G2_ST7567_OS12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
+//U8G2_ST7567_ENH_DG128064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
+//U8G2_ST7567_ENH_DG128064_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
+//U8G2_ST7567_ENH_DG128064I_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
+//U8G2_ST7567_ENH_DG128064I_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
+//U8G2_ST7567_64X32_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
+//U8G2_ST7567_HEM6432_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE); 
+//U8G2_ST7567_ERC13232_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
+//U8G2_ST7567_ERC13232_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
+//U8G2_ST7567_96X65_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
+//U8G2_ST7567_96X65_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
+//U8G2_ST7571_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST7571_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST7571_128X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST7571_128X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST7571_G12896_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST7571_G12896_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST7302_122X250_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST7305_122X250_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST7305_200X200_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST7305_168X384_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST7305_300X400_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST7586S_JLX384160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);             // Uno: Enable U8g2 16 bit mode for this display
+//U8G2_ST7586S_ERC240160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST7586S_YMC240160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST7586S_JLX320160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);             // Uno: Enable U8g2 16 bit mode for this display
+//U8G2_ST75160_JM16096_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST75160_JM16096_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST75161_JLX160160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST75161_JLX160160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST75256_JLX172104_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST75256_JLX172104_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST75256_JLX19296_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST75256_JLX19296_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST75256_JLX16080_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST75256_JLX16080_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST75256_JLX256128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
+//U8G2_ST75256_JLX256128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
+//U8G2_ST75256_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
+//U8G2_ST75256_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
+//U8G2_ST75256_WO256X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
+//U8G2_ST75256_WO256X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
+//U8G2_ST75256_JLX256128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 9, /* data=*/ 8, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
+//U8G2_ST75256_JLX256128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 6, /* reset=*/ 5);  // MKR Zero, Enable U8g2 16 bit mode for this display
+//U8G2_ST75256_JLX256160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
+//U8G2_ST75256_JLX256160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
+//U8G2_ST75256_JLX256160M_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
+//U8G2_ST75256_JLX256160M_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
+//U8G2_ST75256_JLX256160_ALT_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
+//U8G2_ST75256_JLX256160_ALT_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
+//U8G2_ST75256_JLX240160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_ST75256_JLX240160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	
+//U8G2_ST75256_JLX25664_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, enable U8g2 16 bit mode for this display
+//U8G2_ST75320_JLX320240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Uno, Enable U8g2 16 bit mode for this display
+//U8G2_ST75320_JLX320240_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);				// Uno, Enable U8g2 16 bit mode for this display
+//U8G2_NT7534_TG12864R_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
+//U8G2_NT7534_TG12864R_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
+//U8G2_ST7588_JLX12864_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ 5);  
+//U8G2_ST7588_JLX12864_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 5);
+//U8G2_IST3020_ERC19264_1_6800 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 28, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect WR pin with GND
+//U8G2_IST3020_ERC19264_1_8080 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 29, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect RD pin with 3.3V
+//U8G2_IST3020_ERC19264_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_IST3088_320X240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
+//U8G2_IST3088_320X240_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_IST7920_128X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // Round display
+//U8G2_IST7920_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // Round display
+//U8G2_LC7981_160X80_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
+//U8G2_LC7981_160X160_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
+//U8G2_LC7981_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
+//U8G2_LC7981_240X64_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
+//U8G2_LC7981_128X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
+//U8G2_SED1520_122X32_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*dc=*/ A0, /*e1=*/ A3, /*e2=*/ A2, /* reset=*/  A4); 	// Set R/W to low!
+//U8G2_T6963_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
+//U8G2_T6963_256X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
+//U8G2_T6963_160X80_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
+//U8G2_T6963_128X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
+//U8G2_T6963_128X64_ALT_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
+//U8G2_T6963_128X160_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable/wr=*/ 17, /*cs/ce=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
+//U8G2_SED1330_240X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
+//U8G2_SED1330_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
+//U8G2_SED1330_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
+//U8G2_SED1330_256X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0, enable U8g2 16Bit Mode 
+//U8G2_SED1330_256X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E, enable U8g2 16Bit Mode 
+//U8G2_SED1330_320X200_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0, enable U8g2 16Bit Mode 
+//U8G2_SED1330_320X200_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E, enable U8g2 16Bit Mode 
+//U8G2_RA8835_NHD_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
+//U8G2_RA8835_NHD_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
+//U8G2_UC1601_128X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
+//U8G2_UC1601_128X32_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
+//U8G2_UC1601_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
+//U8G2_UC1604_JLX19264_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
+//U8G2_UC1604_JLX19264_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
+//U8G2_UC1609_SLG19264_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
+//U8G2_UC1609_SLG19264_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
+//U8G2_UC1608_ERC24064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
+//U8G2_UC1608_DEM240064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
+//U8G2_UC1608_ERC240120_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
+//U8G2_UC1608_240X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
+//U8G2_UC1610_EA_DOGXL160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
+//U8G2_UC1610_EA_DOGXL160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
+//U8G2_UC1611_EA_DOGM240_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGM240 Test Board
+//U8G2_UC1611_EA_DOGM240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // SW SPI, Due DOGXL240 Test Board
+//U8G2_UC1611_EA_DOGXL240_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGXL240 Test Board
+//U8G2_UC1611_EA_DOGXL240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // SW SPI, Due DOGXL240 Test Board
+//U8G2_UC1611_EW50850_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // 240x160, Connect RD/WR1 pin with 3.3V, CS is aktive high
+//U8G2_UC1611_CG160160_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // Connect WR1 and CD1 pin with 3.3V, connect CS0 with cs, WR0 with enable, CD with dc
+//U8G2_UC1611_IDS4073_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8g2 16Bit Mode 
+//U8G2_UC1611_IDS4073_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Enable U8g2 16Bit Mode 
+//U8G2_UC1617_JLX128128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_UC1617_JLX128128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_UC1628_128X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 17); // UC1628 pin names: enable: /WR, dc: CD
+//U8G2_UC1628_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_UC1628_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_UC1628_256X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_UC1628_256X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_UC1628_256X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_UC1628_256X32_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_UC1638_192X96_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_UC1638_192X96_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_UC1638_192X96_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* reset=*/ 8);  // u8g2 test board: I2C clock/data is same as SPI, I2C default address is 0x78
+//U8G2_UC1638_240X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_UC1638_240X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_UC1638_240X128_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* reset=*/ 8);  // u8g2 test board: I2C clock/data is same as SPI, I2C default address is 0x78
+//U8G2_UC1698_160X160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_UC1698_160X160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
+//U8G2_SSD1606_172X72_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// eInk/ePaper Display
+//U8G2_SSD1607_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// eInk/ePaper Display, original LUT from embedded artists
+//U8G2_SSD1607_GD_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Good Display
+//U8G2_SSD1607_WS_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Waveshare
+//U8G2_IL3820_296X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// WaveShare 2.9 inch eInk/ePaper Display, enable 16 bit mode for this display!
+//U8G2_IL3820_V2_296X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// ePaper Display, lesser flickering and faster speed, enable 16 bit mode for this display!
+//U8G2_LS013B7DH03_128X128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
+//U8G2_LS027B7DH01_400X240_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display, SPI Mode 2
+//U8G2_LS027B7DH01_M0_400X240_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display, SPI Mode 0
+//U8G2_LS013B7DH05_144X168_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ U8X8_PIN_NONE, /* reset=*/ 8);	// there is no DC line for this display
+//U8G2_ST7511_AVD_320X240_1_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable/WR=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8); // Enable U8g2 16Bit Mode and connect RD pin with 3.3V/5V
+//U8G2_ST7511_640X320_1_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable/WR=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8); // Enable U8g2 16Bit Mode and connect RD pin with 3.3V/5V
+//U8G2_S1D15300_LM6023_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_S1D15300_LM6023_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_S1D15300_100X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_S1D15300_100X32_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_S1D15300_100X32I_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_S1D15300_100X32I_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_S1D15721_240X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_S1D15721_240X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_GU800_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_GU800_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_GU800_160X16_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_GU800_160X16_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
+//U8G2_GP1294AI_256X48_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/10, /* dc=*/U8X8_PIN_NONE, /* reset=*/8);
+
+
+
+
+// End of constructor list
+
+
+
+/* button setup for Arduboy Production */
+uint8_t pin_up = A0;
+uint8_t pin_down = A3;
+uint8_t pin_fire = 7;
+
+
+
+
+#define ST_FP 4
+
+/* object types */
+struct _st_ot_struct
+{
+  /* 
+    missle and hit: 
+      bit 0: player missle and trash
+      bit 1: trash, which might hit the player
+  */
+  
+  uint8_t missle_mask;		/* this object is a missle: it might destroy something if the target is_hit_fn says so */ 
+  uint8_t hit_mask;			/* if missle_mask & hit_mask is != 0  then the object can be destroyed */
+  uint8_t points;
+  uint8_t draw_fn;
+  uint8_t move_fn;
+      /* ST_MOVE_FN_NONE, ST_MOVE_FN_X_SLOW */
+  uint8_t destroy_fn;		/* object can be destroyed by a missle (e.g. a missle from the space ship) */
+      /* ST_DESTROY_FN_NONE, ST_DESTROY_FN_SPLIT */
+  uint8_t is_hit_fn;		/* is hit procedure */
+      /* ST_IS_HIT_FN_NONE, ST_IS_HIT_BBOX */
+  uint8_t fire_fn;
+    /* ST_FIRE_FN_NONE, ST_FIRE_FN_X_LEFT */
+  
+};
+typedef struct _st_ot_struct st_ot;
+
+/*
+  objects, which are visible at the play area
+*/
+struct _st_obj_struct
+{
+  uint8_t ot; 			/* object type: zero means, object is not used */
+  int8_t tmp;			/* generic value, used by ST_MOVE_IMPLODE */
+  /* absolute position */
+  /* LCD pixel position is x>>ST_FP and y>>ST_FP */
+  int16_t x, y;
+  int8_t x0,y0,x1,y1;	/* object outline in pixel, reference point is at 0,0 */
+};
+typedef struct _st_obj_struct st_obj;
+
+#define ST_DRAW_NONE 0
+#define ST_DRAW_BBOX 1
+#define ST_DRAW_TRASH1 2
+#define ST_DRAW_PLAYER1 3
+#define ST_DRAW_TRASH2 4
+#define ST_DRAW_PLAYER2 5
+#define ST_DRAW_PLAYER3 6
+#define ST_DRAW_GADGET 7
+#define ST_DRAW_BACKSLASH 8
+#define ST_DRAW_SLASH 9
+#define ST_DRAW_BIG_TRASH 10
+
+#define ST_MOVE_NONE 0
+#define ST_MOVE_X_SLOW 1
+#define ST_MOVE_PX_NORMAL 2
+#define ST_MOVE_PX_FAST 3
+#define ST_MOVE_PLAYER 4
+#define ST_MOVE_PY 5
+#define ST_MOVE_NY 6
+#define ST_MOVE_IMPLODE 7
+#define ST_MOVE_X_FAST 8
+#define ST_MOVE_WALL 9
+#define ST_MOVE_NXPY 10
+#define ST_MOVE_NXNY 11
+
+#define ST_IS_HIT_NONE 0
+#define ST_IS_HIT_BBOX 1
+#define ST_IS_HIT_WALL 2
+
+#define ST_DESTROY_NONE 0
+#define ST_DESTROY_DISAPPEAR 1
+#define ST_DESTROY_TO_DUST 2
+#define ST_DESTROY_GADGET 3
+#define ST_DESTROY_PLAYER 4
+#define ST_DESTROY_PLAYER_GADGETS 5
+#define ST_DESTROY_BIG_TRASH 6
+
+#define ST_FIRE_NONE 0
+#define ST_FIRE_PLAYER1 1
+#define ST_FIRE_PLAYER2 2
+#define ST_FIRE_PLAYER3 3
+
+#define ST_OT_WALL_SOLID 1
+#define ST_OT_BIG_TRASH 2
+#define ST_OT_MISSLE 3
+#define ST_OT_TRASH1 4
+#define ST_OT_PLAYER 5
+#define ST_OT_DUST_PY 6
+#define ST_OT_DUST_NY 7
+#define ST_OT_TRASH_IMPLODE 8
+#define ST_OT_TRASH2 9
+#define ST_OT_PLAYER2 10
+#define ST_OT_PLAYER3 11
+#define ST_OT_GADGET 12
+#define ST_OT_GADGET_IMPLODE 13
+#define ST_OT_DUST_NXPY 14
+#define ST_OT_DUST_NXNY 15
+
+
+/*================================================================*/
+/* graphics object */
+/*================================================================*/
+
+u8g2_t *st_u8g2;
+
+u8g2_uint_t u8g_height_minus_one;
+
+
+#define ST_AREA_HEIGHT (st_u8g2->height - 8)
+#define ST_AREA_WIDTH (st_u8g2->width)
+
+
+/*================================================================*/
+/* object types */
+/*================================================================*/
+
+
+const st_ot st_object_types[] U8X8_PROGMEM =
+{
+    /* 0: empty object type */
+    { 0, 0,  0, ST_DRAW_NONE, ST_MOVE_NONE, ST_DESTROY_DISAPPEAR, ST_IS_HIT_NONE, ST_FIRE_NONE },
+    /* 1: wall, player will be destroyed */
+    { 2, 1, 30, ST_DRAW_BBOX, ST_MOVE_WALL, ST_DESTROY_DISAPPEAR, ST_IS_HIT_WALL, ST_FIRE_NONE },
+    /* ST_OT_BIG_TRASH (2) */
+    { 2, 1,  0, ST_DRAW_BIG_TRASH, ST_MOVE_X_SLOW, ST_DESTROY_BIG_TRASH, ST_IS_HIT_BBOX, ST_FIRE_NONE },
+    /* 3: simple space ship (player) missle */
+    { 1, 0,  0, ST_DRAW_BBOX, ST_MOVE_PX_FAST, ST_DESTROY_DISAPPEAR, ST_IS_HIT_NONE, ST_FIRE_NONE },
+    /* ST_OT_TRASH1 (4): trash */
+    { 2, 1,  0, ST_DRAW_TRASH1, ST_MOVE_X_SLOW, ST_DESTROY_TO_DUST, ST_IS_HIT_BBOX, ST_FIRE_NONE },
+    /* ST_OT_PLAYER (5): player space ship */
+    { 0, 2,  0, ST_DRAW_PLAYER1, ST_MOVE_PLAYER, ST_DESTROY_PLAYER, ST_IS_HIT_BBOX, ST_FIRE_PLAYER1 },
+    /* ST_OT_DUST_PY (6): Last part of trash  */
+    { 0, 0,  0, ST_DRAW_BBOX, ST_MOVE_PY, ST_DESTROY_NONE, ST_IS_HIT_NONE, ST_FIRE_NONE },
+    /* ST_OT_DUST_NY (7): Last part of trash  */
+    { 0, 0,  0, ST_DRAW_BBOX, ST_MOVE_NY, ST_DESTROY_NONE, ST_IS_HIT_NONE, ST_FIRE_NONE },
+    /* ST_OT_TRASH_IMPLODE (8): trash was hit */
+    { 0, 0,  5, ST_DRAW_TRASH1, ST_MOVE_IMPLODE, ST_DESTROY_NONE, ST_IS_HIT_NONE, ST_FIRE_NONE },
+    /* ST_OT_TRASH2 (9): trash */
+    { 2, 1,  0, ST_DRAW_TRASH2, ST_MOVE_X_SLOW, ST_DESTROY_TO_DUST, ST_IS_HIT_BBOX, ST_FIRE_NONE },
+    /* ST_OT_PLAYER2 (10): player space ship+1x enhancement */
+    { 0, 2,  0, ST_DRAW_PLAYER2, ST_MOVE_PLAYER, ST_DESTROY_PLAYER_GADGETS, ST_IS_HIT_BBOX, ST_FIRE_PLAYER2 },
+    /* ST_OT_PLAYER3 (11): player space ship+2x enhancement */
+    { 0, 2,  0, ST_DRAW_PLAYER3, ST_MOVE_PLAYER, ST_DESTROY_PLAYER_GADGETS, ST_IS_HIT_BBOX, ST_FIRE_PLAYER3 },
+    /* ST_OT_GADGET (12): adds enhancements */
+    { 0, 1,  0, ST_DRAW_GADGET, ST_MOVE_X_FAST, ST_DESTROY_GADGET, ST_IS_HIT_BBOX, ST_FIRE_NONE },
+    /* ST_OT_GADGET_IMPLODE (13) */
+    { 0, 0, 20, ST_DRAW_GADGET, ST_MOVE_IMPLODE, ST_DESTROY_NONE, ST_IS_HIT_NONE, ST_FIRE_NONE },
+    /* ST_OT_DUST_NXPY (14): Last part of trash  */
+    { 0, 0,  0, ST_DRAW_BACKSLASH, ST_MOVE_NXPY, ST_DESTROY_NONE, ST_IS_HIT_NONE, ST_FIRE_NONE },
+    /* ST_OT_DUST_NXNY (15): Last part of trash  */
+    { 0, 0,  0, ST_DRAW_SLASH, ST_MOVE_NXNY, ST_DESTROY_NONE, ST_IS_HIT_NONE, ST_FIRE_NONE },
+    
+};
+
+/*================================================================*/
+/* list of all objects on the screen */
+/*================================================================*/
+
+/* use AVR RAMEND constant to derive the number of allowed objects */
+
+#if RAMEND < 0x300 
+#define ST_OBJ_CNT 25
+#else
+//#define ST_OBJ_CNT 45
+#define ST_OBJ_CNT 60
+#endif 
+
+st_obj st_objects[ST_OBJ_CNT];
+
+/*================================================================*/
+/* about players space ship*/
+/*================================================================*/
+
+/* player position */
+uint8_t st_player_pos;
+
+/* points */
+#define ST_POINTS_PER_LEVEL 25
+uint16_t st_player_points;
+uint16_t st_player_points_delayed;
+uint16_t st_highscore = 0;
+
+/*================================================================*/
+/* overall game state */
+/*================================================================*/
+
+#define ST_STATE_PREPARE 0
+#define ST_STATE_IPREPARE 1
+#define ST_STATE_GAME 2
+#define ST_STATE_END 3
+#define ST_STATE_IEND 4
+
+uint8_t st_state = ST_STATE_PREPARE;
+
+/*================================================================*/
+/* game difficulty */
+/*================================================================*/
+uint8_t st_difficulty = 1;
+#define ST_DIFF_VIS_LEN 30
+#define ST_DIFF_FP 5
+uint16_t st_to_diff_cnt = 0;
+
+/*================================================================*/
+/* bitmaps */
+/*================================================================*/
+
+const uint8_t st_bitmap_player1[]  = 
+{ 
+  /* 01100000 */ 0x060,
+  /* 11111000 */ 0x0f8,
+  /* 01111110 */ 0x07e,
+  /* 11111000 */ 0x0f8,
+  /* 01100000 */ 0x060
+};
+
+const uint8_t st_bitmap_player2[] = 
+{   
+  /* 01100000 */ 0x060,
+  /* 01111100 */ 0x078,
+  /* 01100000 */ 0x060,
+  /* 11100000 */ 0x0e0,
+  /* 11111000 */ 0x0f8,
+  /* 01111110 */ 0x07e,
+  /* 11111000 */ 0x0f8,
+  /* 01100000 */ 0x060
+};
+
+const uint8_t st_bitmap_player3[] = 
+{   
+  /* 01100000 */ 0x060,
+  /* 01111100 */ 0x078,
+  /* 01100000 */ 0x060,
+  /* 11100000 */ 0x0e0,
+  /* 11111000 */ 0x0f8,
+  /* 01111110 */ 0x07e,
+  /* 11111000 */ 0x0f8,
+  /* 11100000 */ 0x0e0,
+  /* 01100000 */ 0x060,
+  /* 01111100 */ 0x078,
+  /* 01100000 */ 0x060
+ };
+
+const uint8_t st_bitmap_trash_5x5_1[] = 
+{ 
+  /* 01110000 */ 0x070,
+  /* 11110000 */ 0x0f0,
+  /* 11111000 */ 0x0f8,
+  /* 01111000 */ 0x078,
+  /* 00110000 */ 0x030,
+};
+
+const uint8_t st_bitmap_trash_5x5_2[] = 
+{ 
+  /* 00110000 */ 0x030,
+  /* 11111000 */ 0x0f8,
+  /* 11111000 */ 0x0f8,
+  /* 11110000 */ 0x0f0,
+  /* 01110000 */ 0x070,
+};
+
+const uint8_t st_bitmap_trash_7x7[] = 
+{
+  /* 00111000 */ 0x038,
+  /* 01111100 */ 0x07c,
+  /* 11111100 */ 0x0fc,
+  /* 11111110 */ 0x0fe,
+  /* 11111110 */ 0x0fe,
+  /* 01111110 */ 0x07e,
+  /* 01111000 */ 0x078,
+};
+
+const uint8_t st_bitmap_gadget[] = 
+{ 
+  /* 01110000 */ 0x070,
+  /* 11011000 */ 0x0d8,
+  /* 10001000 */ 0x088,
+  /* 11011000 */ 0x0d8,
+  /* 01110000 */ 0x070,
+};
+
+/*================================================================*/
+/* forward definitions */
+/*================================================================*/
+uint8_t st_rnd(void) U8X8_NOINLINE;
+static st_obj *st_GetObj(uint8_t objnr) U8X8_NOINLINE;
+uint8_t st_GetMissleMask(uint8_t objnr);
+uint8_t st_GetHitMask(uint8_t objnr);
+int8_t st_FindObj(uint8_t ot) U8X8_NOINLINE;
+void st_ClrObjs(void) U8X8_NOINLINE;
+int8_t st_NewObj(void) U8X8_NOINLINE;
+uint8_t st_CntObj(uint8_t ot);
+uint8_t st_CalcXY(st_obj *o) U8X8_NOINLINE;
+void st_SetXY(st_obj *o, uint8_t x, uint8_t y) U8X8_NOINLINE;
+
+void st_FireStep(uint8_t is_auto_fire, uint8_t is_fire) U8X8_NOINLINE;
+
+void st_InitTrash(uint8_t x, uint8_t y, int8_t dir);
+void st_NewGadget(uint8_t x, uint8_t y);
+void st_NewPlayerMissle(uint8_t x, uint8_t y) ;
+void st_NewTrashDust(uint8_t x, uint8_t y, int ot);
+void st_NewTrashDustAreaArgs(int16_t x, int16_t y, int ot); 
+void st_SetupPlayer(uint8_t objnr, uint8_t ot);
+
+
+/*================================================================*/
+/* utility functions */
+/*================================================================*/
+
+char st_itoa_buf[12];
+char *st_itoa(unsigned long v)
+{
+  volatile unsigned char i = 11;
+  st_itoa_buf[11] = '\0';
+  while( i > 0)
+  {
+      i--;
+      st_itoa_buf[i] = (v % 10)+'0';
+      v /= 10;
+      if ( v == 0 )
+	break;
+  }
+  return st_itoa_buf+i;
+}
+
+
+uint8_t st_rnd(void)
+{
+  return rand();
+}
+
+/*	
+  for the specified index number, return the object
+*/
+static st_obj *st_GetObj(uint8_t objnr)
+{
+  return st_objects+objnr;
+}
+
+
+/*
+  check, if this is a missle-like object (that is, can this object destroy something else)
+*/ 
+uint8_t st_GetMissleMask(uint8_t objnr)
+{
+  st_obj *o = st_GetObj(objnr);
+  return u8x8_pgm_read(&(st_object_types[o->ot].missle_mask));
+}
+
+/*
+  check, if this is a missle-like object (that is, can this object destroy something else)
+*/ 
+uint8_t st_GetHitMask(uint8_t objnr)
+{
+  st_obj *o = st_GetObj(objnr);
+  return u8x8_pgm_read(&(st_object_types[o->ot].hit_mask));
+}
+
+/*
+  search an empty object
+*/
+int8_t st_FindObj(uint8_t ot)
+{
+  int8_t i;
+  for( i = 0; i < ST_OBJ_CNT; i++ )
+  {
+    if ( st_objects[i].ot == ot )
+      return i;
+  }
+  return -1;
+}
+
+/*
+  delete all objects
+*/
+
+void st_ClrObjs(void)
+{
+  int8_t i;
+  for( i = 0; i < ST_OBJ_CNT; i++ )
+    st_objects[i].ot = 0;
+}
+
+/*
+  search an empty object
+*/
+int8_t st_NewObj(void)
+{
+  int8_t i;
+  for( i = 0; i < ST_OBJ_CNT; i++ )
+  {
+    if ( st_objects[i].ot == 0 )
+      return i;
+  }
+  return -1;
+}
+
+/*
+  count number of objectes of the provided type
+  st_CntObj(0) will return the number of empty objects, that means if
+  st_CntObj(0) > 0 then st_NewObj() will return  a valid index
+*/
+uint8_t st_CntObj(uint8_t ot)
+{
+  uint8_t i;
+  uint8_t cnt = 0;
+  for( i = 0; i < ST_OBJ_CNT; i++ )
+  {
+    if ( st_objects[i].ot == ot )
+      cnt++;
+  }
+  return cnt;
+}
+
+/*
+  calculate the pixel coordinates of the reference point of an object
+  return rhe x value
+*/
+uint8_t st_px_x, st_px_y; /* pixel within area */
+uint8_t st_CalcXY(st_obj *o)
+{
+  //st_obj *o = st_GetObj(objnr);
+  st_px_y = o->y>>ST_FP;
+  st_px_x = o->x>>ST_FP;
+  return st_px_x;
+}
+
+void st_SetXY(st_obj *o, uint8_t x, uint8_t y)
+{
+  o->x = ((int16_t)x) << ST_FP;
+  o->y = ((int16_t)y) << ST_FP;
+}
+
+/*
+  calculate the object bounding box and place it into some global variables
+*/
+int16_t st_bbox_x0, st_bbox_y0, st_bbox_x1, st_bbox_y1;  
+
+void st_CalcBBOX(uint8_t objnr)
+{
+  st_obj *o = st_GetObj(objnr);
+  
+  st_bbox_x0 = (uint16_t)(o->x>>ST_FP);
+  st_bbox_x1 = st_bbox_x0;
+  st_bbox_x0 += o->x0;
+  st_bbox_x1 += o->x1;
+
+  st_bbox_y0 = (uint16_t)(o->y>>ST_FP);
+  st_bbox_y1 = st_bbox_y0;
+  st_bbox_y0 += o->y0;
+  st_bbox_y1 += o->y1;
+}
+
+/*
+  clip bbox with the view window. requires a call to st_CalcBBOX
+  return 0, if the bbox is totally outside the window
+*/
+uint8_t st_cbbox_x0, st_cbbox_y0, st_cbbox_x1, st_cbbox_y1;
+uint8_t st_ClipBBOX(void)
+{
+  if ( st_bbox_x0 >= ST_AREA_WIDTH )
+    return 0;
+  if ( st_bbox_x0 >= 0 )
+    st_cbbox_x0  = (uint16_t)st_bbox_x0;
+  else
+    st_cbbox_x0 = 0;
+
+  if ( st_bbox_x1 < 0 )
+    return 0;
+  if ( st_bbox_x1 < ST_AREA_WIDTH )
+    st_cbbox_x1  = (uint16_t)st_bbox_x1;
+  else
+    st_cbbox_x1 = ST_AREA_WIDTH-1;
+
+  if ( st_bbox_y0 >= ST_AREA_HEIGHT )
+    return 0;
+  if ( st_bbox_y0 >= 0 )
+    st_cbbox_y0  = (uint16_t)st_bbox_y0;
+  else
+    st_cbbox_y0 = 0;
+
+  if ( st_bbox_y1 < 0 )
+    return 0;
+  if ( st_bbox_y1 < ST_AREA_HEIGHT )
+    st_cbbox_y1  = (uint16_t)st_bbox_y1;
+  else
+    st_cbbox_y1 = ST_AREA_HEIGHT-1;
+  
+  return 1;
+}
+
+
+/*================================================================*/
+/* universal member functions */
+/*================================================================*/
+
+
+uint8_t st_IsOut(uint8_t objnr)
+{
+  st_CalcBBOX(objnr);
+  if ( st_bbox_x0 >= ST_AREA_WIDTH )
+    return 1;
+  if ( st_bbox_x1 < 0 )
+    return 1;
+  if ( st_bbox_y0 >= ST_AREA_HEIGHT )
+    return 1;
+  if ( st_bbox_y1 < 0 )
+    return 1;
+  return 0;
+}
+
+void st_Disappear(uint8_t objnr)
+{
+  st_obj *o = st_GetObj(objnr);
+  st_player_points += u8x8_pgm_read(&(st_object_types[o->ot].points));
+  o->ot = 0;
+}
+
+/*================================================================*/
+/* type dependent member functions */
+/*================================================================*/
+
+void st_Move(uint8_t objnr)
+{
+  st_obj *o = st_GetObj(objnr);
+  switch(u8x8_pgm_read(&(st_object_types[o->ot].move_fn)))
+  {
+    case ST_MOVE_NONE:
+      break;
+    case ST_MOVE_X_SLOW:
+      o->x -= (1<<ST_FP)/8;
+      o->x -= st_difficulty;
+      o->y += (int16_t)o->tmp;
+      if ( o->y >= ((ST_AREA_HEIGHT-1) << ST_FP) || o->y <= 0 )
+	o->tmp = - o->tmp;
+      break;
+    case ST_MOVE_X_FAST:
+      o->x -= (1<<ST_FP)/2;
+      o->y += (int16_t)o->tmp;
+      if ( o->y >= ((ST_AREA_HEIGHT-1) << ST_FP) || o->y <= 0 )
+	o->tmp = - o->tmp;
+      break;
+    case ST_MOVE_PX_NORMAL:
+      o->x += (1<<ST_FP)/4;
+      break;
+    case ST_MOVE_PX_FAST:
+      o->x += (1<<ST_FP);
+      break;
+    case ST_MOVE_PLAYER:
+      o->y = st_player_pos<<ST_FP;
+      break;
+    case ST_MOVE_PY:
+      o->y += 3*ST_FP;
+      break;
+    case ST_MOVE_NY:
+      o->y -= 3*ST_FP;
+      break;
+    case ST_MOVE_NXPY:
+      o->y += 3*ST_FP;
+      o->x -= 3*ST_FP;
+      break;
+    case ST_MOVE_NXNY:
+      o->y -= 3*ST_FP;
+      o->x -= 3*ST_FP;
+      break;
+    case ST_MOVE_IMPLODE:
+      o->tmp++;
+      if ( (o->tmp & 0x03) == 0 )
+      {
+	if ( o->x0 != o->x1 )
+	  o->x0++;
+	else
+	    st_Disappear(objnr);
+      }
+      break;
+    case ST_MOVE_WALL:
+      o->x -= 1;
+      o->x -= (st_difficulty>>1);
+      break;
+  }
+}
+
+void st_DrawBBOX(uint8_t objnr)
+{
+  uint8_t y0, y1;
+  /*st_obj *o = st_GetObj(objnr);*/
+  st_CalcBBOX(objnr);
+  if ( st_ClipBBOX() == 0 )
+    return;
+  /* st_cbbox_x0, st_cbbox_y0, st_cbbox_x1, st_cbbox_y1; */
+
+  
+  // w = st_cbbox_x1-st_cbbox_x0;
+  // w++;
+  // h = st_cbbox_y1-st_cbbox_y0;
+  // h++;
+  
+  
+  //dog_SetVLine(st_cbbox_x0, st_cbbox_y0, st_cbbox_y1);
+  //dog_SetVLine(st_cbbox_x1, st_cbbox_y0, st_cbbox_y1);
+  //dog_SetHLine(st_cbbox_x0, st_cbbox_x1, st_cbbox_y0);
+  //dog_SetHLine(st_cbbox_x0, st_cbbox_x1, st_cbbox_y1);
+
+  u8g2_SetDrawColor(st_u8g2, 1);
+  y0 = u8g_height_minus_one - st_cbbox_y0;
+  y1 = u8g_height_minus_one - st_cbbox_y1;
+  
+  u8g2_DrawFrame(st_u8g2, st_cbbox_x0, y1, st_cbbox_x1-st_cbbox_x0+1, y0-y1+1);
+  
+  //dog_SetBox(st_cbbox_x0, st_cbbox_y0, st_cbbox_x1, st_cbbox_y1);
+
+  /*
+  if ( o->ot == ST_OT_PLAYER )
+  {
+    dog_DrawStr(0, 26, font_4x6, st_itoa(st_cbbox_y0));
+    dog_DrawStr(10, 26, font_4x6, st_itoa(st_cbbox_y1));
+  }
+  */
+}
+
+#ifdef FN_IS_NOT_IN_USE
+void st_DrawFilledBox(uint8_t objnr)
+{
+  st_CalcBBOX(objnr);
+  if ( st_ClipBBOX() == 0 )
+    return;
+  /* st_cbbox_x0, st_cbbox_y0, st_cbbox_x1, st_cbbox_y1; */
+  dog_SetBox(st_cbbox_x0, st_cbbox_y0, st_cbbox_x1, st_cbbox_y1);
+}
+#endif
+
+void st_DrawBitmap(uint8_t objnr, const uint8_t * bm, uint8_t w, uint8_t h)
+{
+  /* st_obj *o = st_GetObj(objnr); */
+  st_CalcBBOX(objnr);
+  /* result is here: int16_t st_bbox_x0, st_bbox_y0, st_bbox_x1, st_bbox_y1 */
+  //dog_SetBitmapP(st_bbox_x0,st_bbox_y1,bm,w,h);
+  
+  u8g2_DrawBitmap(st_u8g2, st_bbox_x0, u8g_height_minus_one - st_bbox_y1, (w+7)/8, h, bm);
+  
+ }
+
+void st_DrawObj(uint8_t objnr)
+{
+  st_obj *o = st_GetObj(objnr);
+  switch(u8x8_pgm_read(&(st_object_types[o->ot].draw_fn)))
+  {
+    case ST_DRAW_NONE:
+      break;
+    case ST_DRAW_BBOX:
+      st_DrawBBOX(objnr);
+      break;
+    case ST_DRAW_TRASH1:
+      st_DrawBitmap(objnr, st_bitmap_trash_5x5_1,o->x1-o->x0+1, 5);
+      break;
+    case ST_DRAW_TRASH2:
+      st_DrawBitmap(objnr, st_bitmap_trash_5x5_2,o->x1-o->x0+1, 5);
+      break;
+    case ST_DRAW_BIG_TRASH:
+      st_DrawBitmap(objnr, st_bitmap_trash_7x7,o->x1-o->x0+1, 7);
+      break;
+    case ST_DRAW_PLAYER1:
+      st_DrawBitmap(objnr, st_bitmap_player1,7,5);
+      break;
+    case ST_DRAW_PLAYER2:
+      st_DrawBitmap(objnr, st_bitmap_player2,7,8);
+      break;
+    case ST_DRAW_PLAYER3:
+      st_DrawBitmap(objnr, st_bitmap_player3,7,11);
+      break;
+    case ST_DRAW_GADGET:
+      /* could use this proc, but... */
+      /* st_DrawBitmap(objnr, st_bitmap_gadget,o->x1-o->x0+1, 5); */
+      /* ... this one looks also funny. */
+      st_DrawBitmap(objnr, st_bitmap_gadget,5,5);
+      break;
+    case ST_DRAW_BACKSLASH:
+      {
+	uint8_t x;
+	uint8_t y;
+	x = st_CalcXY(o);
+	y = st_px_y;
+
+	
+	// dog_SetPixel(x,y);
+	// x++; y--;
+	// dog_SetPixel(x,y);
+	// x++; y--;
+ 	// dog_SetPixel(x,y);
+	
+	u8g2_SetDrawColor(st_u8g2, 1);  
+	u8g2_DrawPixel(st_u8g2, x, u8g_height_minus_one - y);  
+	x++; y--;
+	u8g2_DrawPixel(st_u8g2, x, u8g_height_minus_one - y);  
+	x++; y--;
+	u8g2_DrawPixel(st_u8g2, x, u8g_height_minus_one - y);  	
+     }      
+     break;
+    case ST_DRAW_SLASH:
+      {
+	uint8_t x;
+	uint8_t y;
+	x = st_CalcXY(o);
+	y = st_px_y;
+	
+	// dog_SetPixel(x,y);
+	// x++; y++;
+	// dog_SetPixel(x,y);
+	// x++; y++;
+ 	// dog_SetPixel(x,y);
+	
+	u8g2_SetDrawColor(st_u8g2, 1);  
+	u8g2_DrawPixel(st_u8g2, x, u8g_height_minus_one - y);  
+	x++; y++;
+	u8g2_DrawPixel(st_u8g2, x, u8g_height_minus_one - y);  
+	x++; y++;
+	u8g2_DrawPixel(st_u8g2, x, u8g_height_minus_one - y);  	
+     }      
+     break;
+  }
+}
+
+uint8_t st_IsHitBBOX(uint8_t objnr, uint8_t x, uint8_t y)
+{
+  st_CalcBBOX(objnr);
+  if ( st_ClipBBOX() == 0 ) 
+    return 0;	/* obj is outside (not visible) */
+  if ( x < st_cbbox_x0 )
+    return 0;
+  if ( x > st_cbbox_x1 )
+    return 0;
+  if ( y < st_cbbox_y0 )
+    return 0;
+  if ( y > st_cbbox_y1 )
+    return 0;
+  return 1;
+}
+
+void st_Destroy(uint8_t objnr)
+{
+  int8_t nr;
+  st_obj *o = st_GetObj(objnr);
+  switch(u8x8_pgm_read(&(st_object_types[o->ot].destroy_fn)))
+  {
+    case ST_DESTROY_NONE:      /* only usefull for missels or walls which stay alife */
+      break;
+    case ST_DESTROY_DISAPPEAR:	/* this should be the default operation */
+      st_Disappear(objnr);
+      break;
+    case ST_DESTROY_GADGET:
+      nr = st_FindObj(ST_OT_PLAYER2);
+      if ( nr >= 0 )
+	st_SetupPlayer(nr, ST_OT_PLAYER3);
+      else
+      {
+	nr = st_FindObj(ST_OT_PLAYER);
+	if ( nr >= 0 )
+	  st_SetupPlayer(nr, ST_OT_PLAYER2);
+      }
+      st_NewTrashDustAreaArgs(o->x, o->y, ST_OT_DUST_PY);
+      st_NewTrashDustAreaArgs(o->x, o->y, ST_OT_DUST_NY);
+      o->ot = ST_OT_GADGET_IMPLODE;
+      o->tmp = 0;
+      break;
+    case ST_DESTROY_TO_DUST:
+      st_NewTrashDustAreaArgs(o->x, o->y, ST_OT_DUST_PY);
+      st_NewTrashDustAreaArgs(o->x, o->y, ST_OT_DUST_NY);
+      o->ot = ST_OT_TRASH_IMPLODE;
+      o->tmp = 0;
+      break;
+    case ST_DESTROY_BIG_TRASH:
+      st_NewTrashDustAreaArgs(o->x, o->y, ST_OT_DUST_PY);
+      st_NewTrashDustAreaArgs(o->x, o->y, ST_OT_DUST_NY);
+      st_InitTrash((o->x>>ST_FP)-1, (o->y>>ST_FP)+3, 2+(st_rnd()&3));
+      st_InitTrash((o->x>>ST_FP)-2, (o->y>>ST_FP)-3, -2-(st_rnd()&3));
+      st_Disappear(objnr);
+      break;
+    case ST_DESTROY_PLAYER:
+      st_Disappear(objnr);
+      st_state = ST_STATE_END;
+      o->tmp = 0;
+      break;
+    case ST_DESTROY_PLAYER_GADGETS:
+      /* o->ot = ST_OT_PLAYER; */
+      st_SetupPlayer(objnr, ST_OT_PLAYER);
+      break;
+  }
+}
+
+/*
+  check if the target (objnr) has been hit.
+  st_IsHit() must also destroy the target.
+  return value:
+    0: do not destroy the missle
+    1: destroy the missle
+*/
+uint8_t st_IsHit(uint8_t objnr, uint8_t x, uint8_t y, uint8_t missle_mask)
+{
+  uint8_t hit_mask = st_GetHitMask(objnr);
+  st_obj *o;
+  
+  if ( (hit_mask & missle_mask) == 0 )
+    return 0;
+  
+  o = st_GetObj(objnr);
+  
+  switch(u8x8_pgm_read(&(st_object_types[o->ot].is_hit_fn)))
+  {
+    case ST_IS_HIT_NONE:
+      break;
+    case ST_IS_HIT_BBOX:
+      if ( st_IsHitBBOX(objnr, x, y) != 0 )
+      {
+	st_Destroy(objnr);
+	return 1;
+      }
+      break;
+    case ST_IS_HIT_WALL:
+      if ( st_IsHitBBOX(objnr, x, y) != 0 )
+      {
+	o->x0++;
+	if ( o->x0 < o->x1 )
+	{
+	  st_NewTrashDust(x, y, ST_OT_DUST_NXPY);
+	  st_NewTrashDust(x, y, ST_OT_DUST_NXNY);
+	}
+	else
+	{
+	  st_Destroy(objnr);
+	  st_NewTrashDust(x, y, ST_OT_DUST_NXPY);
+	  st_NewTrashDust(x, y, ST_OT_DUST_NXNY);
+	  st_NewTrashDust(x, y, ST_OT_DUST_NY);
+	  st_NewTrashDust(x, y, ST_OT_DUST_PY);
+	}
+	return 1;
+      }
+      break;
+  }
+  return 0;
+}
+
+
+
+/* update all fire counters */
+uint8_t st_fire_player = 0;
+uint8_t st_fire_period = 51;
+uint8_t st_manual_fire_delay = 20;
+uint8_t st_is_fire_last_value = 0;
+
+/*
+  is_auto_fire == 1
+    is_fire will be ignored, autofire enabled
+  is_auto_fire == 0
+    a transition from 1 to 0 on the is_fire variable will issue a missle
+*/
+void st_FireStep(uint8_t is_auto_fire, uint8_t is_fire)
+{
+  if ( is_auto_fire != 0 )
+  {
+    st_fire_player++;
+    if ( st_fire_player >= st_fire_period )
+      st_fire_player = 0;
+  }
+  else
+  {
+    if ( st_fire_player < st_manual_fire_delay )
+    {
+      st_fire_player++;
+    }
+    else
+    {
+      if ( st_is_fire_last_value == 0 )
+	if ( is_fire != 0 )
+	  st_fire_player = 0;
+    }
+    st_is_fire_last_value = is_fire;
+  }
+}
+
+void st_Fire(uint8_t objnr)
+{
+  st_obj *o = st_GetObj(objnr);
+  uint8_t x;
+  uint8_t y;
+  
+  switch(u8x8_pgm_read(&(st_object_types[o->ot].fire_fn)))
+  {
+    case ST_FIRE_NONE: 
+      break;
+    case ST_FIRE_PLAYER1: 
+      if ( st_fire_player == 0 )
+      {
+	/* create missle at st_px_x and st_px_y */
+	x = st_CalcXY(o);
+	y = st_px_y;
+	st_NewPlayerMissle(x , y );
+      }
+      break;
+    case ST_FIRE_PLAYER2:
+      if ( st_fire_player == 0 )
+      {
+	/* create missle at st_px_x and st_px_y */
+	x = st_CalcXY(o);
+	y = st_px_y;
+	st_NewPlayerMissle(x , y );
+	st_NewPlayerMissle(x , y+4 );
+      }
+      break;
+    case ST_FIRE_PLAYER3:
+      if ( st_fire_player == 0 )
+      {
+	/* create missle at st_px_x and st_px_y */
+	x = st_CalcXY(o);
+	y = st_px_y;
+	st_NewPlayerMissle(x , y );
+	st_NewPlayerMissle(x , y+4 );
+	st_NewPlayerMissle(x , y-4 );
+      }
+      break;
+  }
+}
+
+/*================================================================*/
+/* object init functions */
+/*================================================================*/
+
+/*
+  x,y are pixel coordinats within the play arey
+*/
+void st_NewGadget(uint8_t x, uint8_t y)
+{
+  st_obj *o;
+  int8_t objnr = st_NewObj();
+  if ( objnr < 0 )
+    return;
+  o = st_GetObj(objnr);
+  st_SetXY(o, x, y);
+  o->ot = ST_OT_GADGET;
+  o->tmp = 8;
+  //o->x = (x)<<ST_FP;
+  //o->y = (y)<<ST_FP;
+  o->x0 = -3;
+  o->x1 = 1;
+  o->y0 = -2;
+  o->y1 = 2;
+}
+
+/*
+  x,y are pixel coordinats within the play arey
+  dir: direction
+    0: random
+   != 0 --> assigned
+*/
+void st_InitTrash(uint8_t x, uint8_t y, int8_t dir)
+{
+  st_obj *o;
+  int8_t objnr = st_NewObj();
+  if ( objnr < 0 )
+    return;
+  o = st_GetObj(objnr);
+  if ( (st_rnd() & 1) == 0 )
+    o->ot = ST_OT_TRASH1;
+  else
+    o->ot = ST_OT_TRASH2;
+  if ( dir == 0 )
+  {
+    o->tmp = 0;
+    if ( st_rnd() & 1 )
+    {
+      if ( st_rnd() & 1 )
+	o->tmp++;
+      else
+	o->tmp--;
+    }
+  }
+  else
+  {
+    o->tmp = dir;
+  }
+  st_SetXY(o, x, y);
+  //o->x = (x)<<ST_FP;
+  //o->y = (y)<<ST_FP;
+  o->x0 = -3;
+  o->x1 = 1;
+  o->y0 = -2;
+  o->y1 = 2;
+  if ( st_difficulty >= 5 )
+  {
+    if ( (st_rnd() & 3) == 0 )
+    {
+      o->ot = ST_OT_BIG_TRASH;
+      o->y0--;
+      o->y1++;
+      o->x0--;
+      o->x1++;
+    }
+  }
+}
+
+/*
+  x,y are pixel coordinats within the play arey
+*/
+void st_NewTrashDust(uint8_t x, uint8_t y, int ot)
+{
+  st_obj *o;
+  int8_t objnr = st_NewObj();
+  if ( objnr < 0 )
+    return;
+  o = st_GetObj(objnr);
+  o->ot = ot;
+  st_SetXY(o, x, y);
+  //o->x = (x)<<ST_FP;
+  //o->y = (y)<<ST_FP;
+  o->x0 = 0;
+  o->x1 = 0;
+  o->y0 = -2;
+  o->y1 = 2;
+}
+
+void st_NewTrashDustAreaArgs(int16_t x, int16_t y, int ot)
+{
+  st_NewTrashDust(x>>ST_FP, y>>ST_FP, ot);
+}
+
+
+void st_NewWall(void)
+{
+  st_obj *o;
+  int8_t objnr = st_NewObj();
+  int8_t h;
+  if ( objnr < 0 )
+    return;
+  o = st_GetObj(objnr);
+  o->ot = ST_OT_WALL_SOLID;
+  h = st_rnd();
+  h &= 63;
+  h = (int8_t)(((int16_t)h*(int16_t)(ST_AREA_HEIGHT/4))>>6);
+  h += ST_AREA_HEIGHT/6;
+
+  o->x0 = 0;
+  o->x1 = 5;
+  o->x = (ST_AREA_WIDTH-1)<<ST_FP;
+ 
+  if ( (st_rnd() & 1) == 0 )
+  {
+    o->y = (ST_AREA_HEIGHT-1)<<ST_FP;
+    
+    o->y0 = -h;
+    o->y1 = 0;
+  }
+  else
+  {
+    o->y = (0)<<ST_FP;
+    o->y0 = 0;
+    o->y1 = h;
+  }
+}
+
+void st_NewPlayerMissle(uint8_t x, uint8_t y)
+{
+  st_obj *o;
+  int8_t objnr = st_NewObj();
+  if ( objnr < 0 )
+    return;
+  o = st_GetObj(objnr);
+  o->ot = ST_OT_MISSLE;
+  st_SetXY(o, x, y);
+  //o->x = x<<ST_FP;
+  //o->y = y<<ST_FP;
+  o->x0 = -4;
+  o->x1 = 1;
+  o->y0 = 0;
+  o->y1 = 0;
+}
+
+void st_SetupPlayer(uint8_t objnr, uint8_t ot)
+{
+  st_obj *o = st_GetObj(objnr);
+  switch(ot)
+  {
+    case ST_OT_PLAYER:
+      o->ot = ot;
+      o->y0 = -2;
+      o->y1 = 2;
+      break;
+    case ST_OT_PLAYER2:
+      o->ot = ot;
+      o->y0 = -2;
+      o->y1 = 5;
+      break;
+    case ST_OT_PLAYER3:
+      o->ot = ot;
+      o->y0 = -5;
+      o->y1 = 5;
+      break;
+  }
+}
+
+void st_NewPlayer(void)
+{
+  st_obj *o;
+  int8_t objnr = st_NewObj();
+  if ( objnr < 0 )
+    return;
+  o = st_GetObj(objnr);
+  o->x = 6<<ST_FP;
+  o->y = (ST_AREA_HEIGHT/2)<<ST_FP;
+  o->x0 = -6;
+  o->x1 = 0;
+  st_SetupPlayer(objnr, ST_OT_PLAYER);
+}
+
+/*================================================================*/
+/* trash creation */
+/*================================================================*/
+
+void st_InitDeltaWall(void)
+{
+  uint8_t i;
+  uint8_t cnt = 0;
+  uint8_t max_x = 0;
+  uint8_t max_l;
+  
+  uint8_t min_dist_for_new = 40;
+  uint8_t my_difficulty = st_difficulty;
+  
+  if ( st_difficulty >= 2 )
+  {
+    
+    max_l = ST_AREA_WIDTH;
+    max_l -= min_dist_for_new;
+    
+    if ( my_difficulty > 30 )
+      my_difficulty = 30;
+    min_dist_for_new -= my_difficulty;
+    
+    for( i = 0; i < ST_OBJ_CNT; i++ )
+    {
+      if ( st_objects[i].ot == ST_OT_WALL_SOLID )
+      {
+	cnt++;
+	if ( max_x < (st_objects[i].x>>ST_FP) )
+	  max_x = (st_objects[i].x>>ST_FP);
+      }
+    }    
+    /* if ( cnt < upper_trash_limit ) */
+    if ( max_x < max_l ) 
+    {
+      st_NewWall();
+    }
+  }
+}
+
+
+void st_InitDeltaTrash(void)
+{
+  uint8_t i;
+  uint8_t cnt = 0;
+  uint8_t max_x = 0;
+  uint8_t max_l;
+  
+  uint8_t upper_trash_limit = ST_OBJ_CNT-7;
+  uint8_t min_dist_for_new = 20;
+  uint8_t my_difficulty = st_difficulty;
+  
+  if ( my_difficulty > 14 )
+    my_difficulty = 14;
+  min_dist_for_new -= my_difficulty;
+  
+  for( i = 0; i < ST_OBJ_CNT; i++ )
+  {
+    if ( st_objects[i].ot == ST_OT_TRASH1 || st_objects[i].ot == ST_OT_TRASH2 || st_objects[i].ot == ST_OT_GADGET  || st_objects[i].ot == ST_OT_BIG_TRASH )
+    {
+      cnt++;
+      if ( max_x < (st_objects[i].x>>ST_FP) )
+	max_x = (st_objects[i].x>>ST_FP);
+    }
+  }
+  
+  max_l = ST_AREA_WIDTH;
+  max_l -= min_dist_for_new;
+  
+  if ( cnt < upper_trash_limit )
+    if ( max_x < max_l ) 
+    {
+      if (  (st_difficulty >= 3)  && ((st_rnd() & 7) == 0) )
+	st_NewGadget(ST_AREA_WIDTH-1, rand() & (ST_AREA_HEIGHT-1));
+      else
+	st_InitTrash(ST_AREA_WIDTH-1, rand() & (ST_AREA_HEIGHT-1),0 );
+    }
+}
+
+void st_InitDelta(void)
+{
+  st_InitDeltaTrash();
+  st_InitDeltaWall();
+  /*
+
+  uint8_t cnt;
+  cnt = st_CntObj(2);
+  if ( cnt == 0 )
+    st_InitBrick1();
+  */
+}
+
+/*================================================================*/
+/* API: game draw procedure */
+/*================================================================*/
+
+void st_DrawInGame(uint8_t fps)
+{
+  uint8_t i;
+  /* draw all objects */
+  for( i = 0; i < ST_OBJ_CNT; i++ )
+      st_DrawObj(i);
+  
+  //dog_ClrBox(0, ST_AREA_HEIGHT, st_u8g2->width-1, ST_AREA_HEIGHT+3);
+
+  u8g2_SetDrawColor(st_u8g2, 0);
+  u8g2_DrawBox(st_u8g2, 0, u8g_height_minus_one - ST_AREA_HEIGHT-3, st_u8g2->width, 4);
+  
+  u8g2_SetDrawColor(st_u8g2, 1);
+  u8g2_DrawHLine(st_u8g2, 0, u8g_height_minus_one - ST_AREA_HEIGHT+1, ST_AREA_WIDTH);
+  u8g2_DrawHLine(st_u8g2, 0, u8g_height_minus_one, ST_AREA_WIDTH);
+  u8g2_SetFont(st_u8g2, u8g_font_4x6r);
+  u8g2_DrawStr(st_u8g2, 0, u8g_height_minus_one - ST_AREA_HEIGHT, st_itoa(st_difficulty));
+  u8g2_DrawHLine(st_u8g2, 10, u8g_height_minus_one - ST_AREA_HEIGHT-3, (st_to_diff_cnt>>ST_DIFF_FP)+1);
+  u8g2_DrawVLine(st_u8g2, 10, u8g_height_minus_one - ST_AREA_HEIGHT-4, 3);
+  u8g2_DrawVLine(st_u8g2, 10+ST_DIFF_VIS_LEN, u8g_height_minus_one - ST_AREA_HEIGHT-4, 3);
+  
+  
+  /* player points */
+  u8g2_DrawStr(st_u8g2, ST_AREA_WIDTH-5*4-2, u8g_height_minus_one - ST_AREA_HEIGHT, st_itoa(st_player_points_delayed));
+  
+  
+  /* FPS output */
+  if ( fps > 0 )
+  {
+    //i = dog_DrawStr(ST_AREA_WIDTH-5*4-2-7*4, ST_AREA_HEIGHT, font_4x6, "FPS:");
+    i = u8g2_DrawStr(st_u8g2, ST_AREA_WIDTH-5*4-2-7*4, u8g_height_minus_one - ST_AREA_HEIGHT, "FPS:");
+
+    //dog_DrawStr(ST_AREA_WIDTH-5*4-2-7*4+i, ST_AREA_HEIGHT, font_4x6, st_itoa(fps));
+    u8g2_DrawStr(st_u8g2, ST_AREA_WIDTH-5*4-2-7*4+i, u8g_height_minus_one - ST_AREA_HEIGHT, st_itoa(fps));
+  }
+  /*dog_DrawStr(60+i, ST_AREA_HEIGHT, font_4x6, st_itoa(st_CntObj(0)));*/
+}
+
+void st_Draw(uint8_t fps)
+{
+  switch(st_state)
+  {
+    case ST_STATE_PREPARE:
+    case ST_STATE_IPREPARE:
+      //dog_DrawStr(0, (st_u8g2->height-6)/2, font_4x6, "SpaceTrash");
+      u8g2_SetFont(st_u8g2, u8g_font_4x6r);
+      u8g2_SetDrawColor(st_u8g2, 1);
+      //dog_DrawStrP(0, (st_u8g2->height-6)/2, font_4x6, DOG_PSTR("SpaceTrash"));
+      u8g2_DrawStr(st_u8g2, 0, u8g_height_minus_one - (st_u8g2->height-6)/2, "SpaceTrash");
+      //dog_SetHLine(st_u8g2->width-st_to_diff_cnt-10, st_u8g2->width-st_to_diff_cnt, (st_u8g2->height-6)/2-1);
+      u8g2_DrawHLine(st_u8g2, st_u8g2->width-st_to_diff_cnt-10, u8g_height_minus_one - (st_u8g2->height-6)/2+1, 11);
+      break;
+    case ST_STATE_GAME:
+      st_DrawInGame(fps);
+      break;
+    case ST_STATE_END:
+    case ST_STATE_IEND:
+      u8g2_SetFont(st_u8g2, u8g_font_4x6r);
+      u8g2_SetDrawColor(st_u8g2, 1);
+      //dog_DrawStr(0, (st_u8g2->height-6)/2, font_4x6, "Game Over");
+      //dog_DrawStrP(0, (st_u8g2->height-6)/2, font_4x6, DOG_PSTR("Game Over"));
+      u8g2_DrawStr(st_u8g2, 0, u8g_height_minus_one - (st_u8g2->height-6)/2, "Game Over");
+      //dog_DrawStr(50, (st_u8g2->height-6)/2, font_4x6, st_itoa(st_player_points));
+      u8g2_DrawStr(st_u8g2, 50, u8g_height_minus_one - (st_u8g2->height-6)/2, st_itoa(st_player_points));
+      //dog_DrawStr(75, (st_u8g2->height-6)/2, font_4x6, st_itoa(st_highscore));
+      u8g2_DrawStr(st_u8g2, 75, u8g_height_minus_one - (st_u8g2->height-6)/2, st_itoa(st_highscore));
+      //dog_SetHLine(st_to_diff_cnt, st_to_diff_cnt+10, (st_u8g2->height-6)/2-1);
+      u8g2_DrawHLine(st_u8g2, st_to_diff_cnt, u8g_height_minus_one - (st_u8g2->height-6)/2+1, 11);
+      break;
+  }
+}
+
+void st_SetupInGame(void)
+{
+  st_player_points = 0;
+  st_player_points_delayed = 0;
+  st_difficulty = 1;
+  st_to_diff_cnt = 0;
+  st_ClrObjs();
+  st_NewPlayer();
+  /* st_InitBrick1(); */
+}
+
+
+/*================================================================*/
+/* API: game setup */
+/*================================================================*/
+
+void st_Setup(u8g2_t *u8g)
+{
+  st_u8g2 = u8g;
+  u8g2_SetBitmapMode(u8g, 1);
+  u8g_height_minus_one = u8g->height;
+  u8g_height_minus_one--;
+}
+
+/*================================================================*/
+/* API: game step execution */
+/*================================================================*/
+
+/*
+  player_pos: 0..255
+*/
+void st_StepInGame(uint8_t player_pos, uint8_t is_auto_fire, uint8_t is_fire)
+{
+  uint8_t i, j;
+  uint8_t missle_mask;
+  
+  /* rescale player pos */
+  //st_player_pos = ((uint16_t)player_pos * (uint16_t)ST_AREA_HEIGHT)/256;
+  if ( player_pos < 64 )
+    st_player_pos = 0;
+  else if ( player_pos >= 192 )
+    st_player_pos = ST_AREA_HEIGHT-2-1;
+  else 
+    st_player_pos = ((uint16_t)((player_pos-64)) * (uint16_t)(ST_AREA_HEIGHT-2))/128;
+  st_player_pos+=1;
+  /* move all objects */
+  for( i = 0; i < ST_OBJ_CNT; i++ )
+    st_Move(i);
+
+  /* check for objects which left the play area */
+  for( i = 0; i < ST_OBJ_CNT; i++ )
+    if ( st_objects[i].ot != 0 )
+      if ( st_IsOut(i) != 0 )
+	st_Disappear(i);
+      
+  /* missle and destruction handling */
+  for( i = 0; i < ST_OBJ_CNT; i++ )
+  {
+    missle_mask = st_GetMissleMask(i);
+    if ( missle_mask != 0 )						/* should we apply missle handling? */
+      if ( st_CalcXY(st_objects+i) != 0 )						/* yes: calculate pixel reference point (st_px_x, st_px_y) */
+	for( j = 0; j < ST_OBJ_CNT; j++ )			/* has any other object been hit? */
+	  if ( i != j )							/* except missle itself... */
+	    if ( st_IsHit(j, st_px_x, st_px_y, missle_mask) != 0 )		/* let the member function decide */
+	    {									/* let the member function destroy the object if required */
+	      st_Destroy(i);
+	    }
+  }
+  
+  /* handle fire counter */
+  st_FireStep(is_auto_fire, is_fire);
+  
+  /* fire */
+  for( i = 0; i < ST_OBJ_CNT; i++ )
+    st_Fire(i);
+	  
+  /* create new objects */
+  st_InitDelta();
+	
+  /* increase difficulty */
+	    
+  st_to_diff_cnt++;
+  if ( st_to_diff_cnt == (ST_DIFF_VIS_LEN<<ST_DIFF_FP) )
+  {
+    st_to_diff_cnt = 0;
+    st_difficulty++;
+    st_player_points += ST_POINTS_PER_LEVEL;
+  }  
+  
+  /* update visible player points */
+  if ( st_player_points_delayed < st_player_points )
+    st_player_points_delayed++;
+}
+  
+void st_Step(uint8_t player_pos, uint8_t is_auto_fire, uint8_t is_fire)
+{
+  switch(st_state)
+  {
+    case ST_STATE_PREPARE:
+      st_to_diff_cnt = st_u8g2->width-10;		/* reuse st_to_diff_cnt */
+      st_state = ST_STATE_IPREPARE;
+      break;
+    case ST_STATE_IPREPARE:
+      st_to_diff_cnt--;
+      if ( st_to_diff_cnt == 0 )
+      {
+	st_state = ST_STATE_GAME;
+	st_SetupInGame();
+      }
+      break;
+    case ST_STATE_GAME:
+      st_StepInGame(player_pos, is_auto_fire, is_fire);
+      break;
+    case ST_STATE_END:
+      st_to_diff_cnt = st_u8g2->width-10;		/* reuse st_to_diff_cnt */
+      if ( st_highscore < st_player_points)
+	st_highscore = st_player_points;
+      st_state = ST_STATE_IEND;
+      break;
+    case ST_STATE_IEND:
+      st_to_diff_cnt--;
+      if ( st_to_diff_cnt == 0 )
+	st_state = ST_STATE_PREPARE;
+      break;
+  }
+}
+
+
+
+void setup(void) {
+  u8g2.begin(); 
+}
+
+uint8_t a;
+uint8_t b;
+uint8_t y = 128;
+
+void loop(void) {
+
+  u8g2.setFont(u8g2_font_6x10_tr);
+  u8g2.setFontDirection(0);
+  u8g2.setFontRefHeightAll();
+
+  st_Setup(u8g2.getU8g2());
+  for(;;)
+  {
+    st_Step(y, /* is_auto_fire */ 0, /* is_fire */ digitalRead(pin_fire));
+    u8g2.firstPage();
+    do
+    {
+      st_Draw(0);
+    } while( u8g2.nextPage() );
+    
+    if ( digitalRead(pin_down) ) {
+      y++;
+    }
+    
+    if ( digitalRead(pin_up) ) {
+      y--;
+    }
+  }
+}
+
+