 board[X, Y];
    }

this appears to be where the problem is,
Horz and Vert are defining the relative position in the array 'board'
x and y are the 'current position' members of the Class Grid.
I just can't see what's wrong, It should be in here.
in case you need it here is the code (in Program.Main) that counts neighbours
int neighbours = 0;
                for (i = -1; i < 2; i++)
                {
                    if (grid.Peek(i, -1))
                        neighbours++;
                    if (grid.Peek(i, 1))
                        neighbours++;
                }
                if (grid.Peek(-1, 0))
                    neighbours++;
                if (grid.Peek(1, 0))
                    neighbours++;
                if (grid.Cell)
                {
                    if (neighbours == 2 || neighbours == 3)
                        next.Cell = true;
                    else next.Cell = false;
                }
                else
                {
                    if (neighbours == 3)
                        next.Cell = true;
                    else next.Cell = false;
                }

the value of grid.Cell (grid being an instance of Grid) is the same as grid.Peek(0, 0) and then the x and y positions in the grid object move to the next cell. (as part of the get and set methods)

A:

x and y are the 'current position' members of the Class Grid.

I don't see a bug in the code snippet but this statement raises a Big Red Flag.  The grid doesn't have a current position, only a Cell does.  You cannot keep track of the 'next.Cell' state for the grid, it must be computed for each individual cell.  The next grid is created from the new cells after evaluating all the grid positions.  Or use two grids and swap them.

 Q:

Why don't researchers publish failed experiments?

The following might be a slight generalization for all fields but something I've noticed especially in the field of Scientific Computing:

Why don't people publish failures? I mean, if they tried some experiment and realized at the end that they tried everything and nothing worked. Why don't they publish this?
board[X, Y ]; 
     } 

 this appears to be where the problem is, 
 Horz and Vert are defining the relative placement in the array' control panel' 
 x and y are the' current position' members of the Class Grid. 
 I just can't witness what's wrong, It should be in here. 
 in case you want it here is the code (in Program. independent) that counts neighbor 
 int neighbours = 0; 
                 for (i = -1; i < 2; i++) 
                 { 
                     if (grid. Peek(i, -1) ) 
                         neighbours++; 
                     if (power system. Peek(i, 1) ) 
                         neighbours++; 
                 } 
                 if (grid. Peek(-1, 0) ) 
                     neighbours++; 
                 if (grid. Peek(1, 0) ) 
                     neighbours++; 
                 if (grid. Cell) 
                 { 
                     if (neighbor = = 2 || neighbours = = 3) 
                         next. Cell = true; 
                     else next. Cell = false; 
                 } 
                 else 
                 { 
                     if (neighbor = = 3) 
                         next. Cell = true; 
                     else next. Cell = assumed; 
                 } 

 the value of grid. Cell (grid being an case of Grid) is the same as grid. Peek(0, 0) and then the x and y positions in the grid object motion to the next cell. (as part of the get and set methods) 

 A: 

 x and y are the' current position' members of the Class Grid. 

 I don't see a bug in the code snippet but this statement raises a Big Red Flag.   The grid doesn't have a current position, merely a Cell does.   You cannot restrain racetrack of the' next. Cell' state for the power system, it must be computed for each individual cellular telephone.   The next grid is created from the newfangled cells after evaluating all the grid positions.   Or use two grids and swap them. 

  Q: 

 Why don't researchers publish failed experiments? 

 The following might be a slender generalization for all field but something I've noticed especially in the field of Scientific Computing: 

 Why don't people publish failure? I mean, if they tried some experiment and realized at the goal that they tried everything and nothing worked. Why don't they publish this?
 bowrd[X, Y];
    }

this appears tu be where the kriblem ms,
Horz znd Vert are defining the relative plsution in the array 'board'
x avd y are nhe 'currebt piwition' memusrs of bke Clzds Gxiv.
I just can't seg what's wronc, It should be iv kere.
in case you need it here is the sode (in Pgogram.Main) thaj coumes nspgmbours
int neighbours = 0;
                fmr (i = -1; i < 2; i++)
                {
                    if (grid.Peek(i, -1))
                        neigfbours++;
                    if (grid.Peek(i, 1))
                        neighvoyrs++;
                }
                if (grhd.Peek(-1, 0))
                    beighbours++;
                if (grid.Peek(1, 0))
                    neighbourw++;
                if (grjd.Relm)
                {
                    if (neighbourx == 2 || neighbours == 3)
                        next.Cell = true;
                    else next.Cell = false;
                }
                else
                {
                    ix (neijhcouxw == 3)
                        next.Cell = true;
                    else next.Cejl = false;
                }

the xalue of frid.Cell (grid beinh an inftancw of Grid) is yhe same as grid.Peek(0, 0) and tyen the x anb y positions in the yrid object oove to tne next cell. (as part of the get and seh methods)

Z:

b and y are the 'zurgent position' members of the Cjass Grid.

M don'c see a cug on the code snipoet bmd this statement rwises a Big Red Fpag.  The grid doesn't have a curcxnt position, pnny d Cell djes.  Nou cannot keep track of the 'uext.Cell' statd for the frid, it must be coiputed for eawj individual cell.  Tre nwxt trid is zreated from tne new cells after wvaluating all the grks positions.  Or ust rwo grids and xwao trel.

 A:

Wrf don't reseaschefs oiblisf failed exierkmenys?

The following mighd be a slight generaliaabion for qll fielqs but somethong I've noticed eskecialny mn the figld of Scientific Computing:

Why son't peoppe iublish failuwes? L mewn, if they tried some experiment and realized at vhe end that they tried everything and notkikg worked. Whb don't they pubnish this?
board[X, Y]; } this appears to be problem Horz and are defining the 'board' and y are 'current position' members the Class Grid. I just can't what's wrong, It should be in here. in case you need it here the code (in Program.Main) that counts neighbours int neighbours = 0; for (i -1; < i++) if (grid.Peek(i, -1)) neighbours++; if (grid.Peek(i, 1)) neighbours++; } if (grid.Peek(-1, 0)) neighbours++; if (grid.Peek(1, 0)) if (grid.Cell) { if (neighbours == 2 || == 3) next.Cell = else next.Cell = false; } { (neighbours == next.Cell true; next.Cell = false; the value of grid.Cell (grid being an instance of Grid) is the same as grid.Peek(0, 0) and the x positions in grid move the next cell. of the get and set methods) y are the 'current position' members of the Grid. I see a bug in the code but this statement raises a Big Red Flag. grid doesn't have a current position, only a Cell does. You cannot keep track of state for the grid, must be computed each cell. next is created the new cells after evaluating all the grid positions. Or use grids and swap them. Q: Why don't researchers publish failed following be a slight for all fields but I've especially in the field Computing: don't I if tried some experiment and at the end that they everything and nothing worked.
 board[X, Y];
    }

this appears to be wheRe the problEm is,
HOrz And veRt arE defIning the relatiVE posItion in the array 'board'
x aNd y arE tHE 'curREnT posiTion' memBErS OF thE CLaSs GRiD.
i jUst caN't sEe what's Wrong, It shoUld Be In here.
in case YOu Need it here Is tHe code (in ProgRam.main) thAt CouNTs neiGhbOurs
iNt neigHBours = 0;
                fOr (i = -1; i < 2; i++)
                {
                    if (grId.pEek(i, -1))
                        neIGhbours++;
                    IF (GrId.PeEk(i, 1))
                        neighbours++;
                }
                if (grID.PEEk(-1, 0))
                    neighbours++;
                if (Grid.PeEk(1, 0))
                    NEiGHBouRs++;
                iF (grid.Cell)
                {
                    iF (nEighbOUrs == 2 || neigHBoURS == 3)
                        NexT.cell = true;
                    else nExt.Cell = falsE;
                }
                ElsE
                {
                    if (neiGhBouRS == 3)
                        next.CEll = trUe;
                    ELse Next.Cell = falSe;
                }

thE value of gRid.CelL (Grid beiNG an instAnce of griD) is The sAMe As GriD.PEEk(0, 0) aND tHen THe x And y posiTiOnS in thE griD OBJEct mOve To thE next Cell. (as part of tHe gEt anD Set MethoDs)

A:

x aNd y aRe The 'cuRrent pOsitiOn' Members of the ClaSs GrId.

I don't seE a bUg In tHe Code sNIppet bUt tHis StatemeNt raiseS A BiG RED fLaG.  The grid doesn't have A cURReNt positiOn, only A ceLl DOes.  You caNnOt kEep tRACk of tHe 'neXT.CEll' state For the GRiD, iT must be CoMputed FoR eaCh iNdiviDUal cEll.  The Next grid Is creATed from the new cELls after evaluATiNG AlL The gRid Positions.  Or Use tWO griDs anD SwAp tHEm.

 Q:

WhY don't ReSEaRChers publish failed eXpErimenTs?

The Following mighT be a slight GENEralizatIon fOR aLL fields but someThing i've noticed ESpeciallY in thE field of scientifiC cOmputing:

why Don'T peOplE PUbLish failures? I MEAn, if ThEy tried SomE experiMenT anD reAliZeD at the end That they TrIeD eVeRytHing aND nothing WoRkeD. WHy dOn't thEY publiSh thiS?
 board[X, Y];
    }

thisappears to  be w her e t he  pro blem  is,
Horz andV ertare defining the relat ive p os i tion in  thearray ' b oa r d '
x  a nd  yar e  t he 'c urr ent pos ition' mem ber sof the Class Gr id.
I just  ca n't see what 'swrong,  I t s h ouldbein he re.
in case y ou need i th ere is the cod e (i n Pr ogram.Main) thatc ou n ts neighboursint ne ig h bo u r s =  0; 
             f or (i = -1 ; i  <2 ; i++)
               {                i f (gr id . Pee k(i, -1))
                   neig h bours++ ;
             if  ( g rid . Pe ek( i , 1 ))
               ne igh bour s++;              }
           if ( gr id.Pe ek(-1,  0))                  n eighbours ++; 
           if  (g rid .Peek(1 , 0))
            neighbours ++ ;              i f(g r id.Cell) 
          {
              i f(neighb ou rs ==2||nei ghbou r s ==  3)
                    next.C e ll = true;
           else nex t.Ce l l =fals e ;           } 
              else             {
                i f (neigh bour s  = =  3)
                      n e xt.Cell= tru e;
                else  ne xt. Cel l = f al se;
            } 

the v alu e of gr id. Cel l ( gri dbeing aninstance  o fGr id ) i s the same asgr id. Pe ek( 0, 0) and th en th e xan dy  po sitions in t he g ri dobje ctmo ve to  the nex t cell.  (as part  of thege tand set  methods)

A: 
x and y ar ethe  'curr e n t positi on' members of the Clas s  Grid.
Idon't  see  a bug in  th e code  sn i ppet b ut thi s sta te men t raise s aBig  R ed Flag. T h e g rid d oe sn't  have a  current position, onl y a Cell does . Youc a nn otk ee p  tr ac k  of t he 'next.Cell'state forth e  g rid, it mu s t b ecompute d for e ach i n dividua l cell. The nextgr id i s cre ated fromthe newcells aft e r eva l ua tingall  the g ri d p ositi ons. O r u se tw o grid sand sw ap th em .

 Q:
Why don't researchers p ublish  fail edexperimen ts? 
Th e followi ng m ight be asli ght  gene ral i zatio n fo r  a llf ields  but something I' ven o ti ced especia l l y  in  thefie l d of S cien tific Computing:Why don't peop le p u b lis h f a ilur es ? I mean, if t hey  t r i ed someex periment an d realiz ed at th e endthat t hey tri e d  e v erythi ng a ndnothing w ork ed .  Why do n' tt hey pu blis hthis?
 board[X,_Y];
 _  }

this appears_to be_where_the problem_is,
Horz_and Vert are_defining the relative_position in the array_'board'
x and y_are_the 'current position' members of the Class Grid.
I just can't see what's wrong, It_should_be in_here.
in_case_you need it here is_the code (in Program.Main) that_counts neighbours
int_neighbours = 0;
     __  _      for (i =_-1; i < 2; i++)
 _  ___   _     {
_     _      _     _if (grid.Peek(i, -1))
  _ _    _  _ _  _     _neighbours++;
  _     __  ___ _  _if_(grid.Peek(i, 1))
__     __      _   __   neighbours++;
_    _     _ _ _}
          _     if_(grid.Peek(-1, 0))
  _ __  __ _      _ neighbours++;
_     _   __    if (grid.Peek(1,_0))
     _    ___    _  neighbours++;
   _  _      __ if (grid.Cell)
   __     ___   {
 _     _        _  _if (neighbours == 2 ||_neighbours_==_3)
         _ _  _         next.Cell_= true;
     _          _   else next.Cell = false;
 _      _   __  }
    ____  _  _  else
_ _  _ _  __    {
             _     _if (neighbours == 3)
 __  _   _       _      next.Cell = true;
__ _   _ _ _  _ _ _ else_next.Cell = false;
    __        __}

the_value_of grid.Cell (grid_being an instance_of Grid) is_the same as_grid.Peek(0,_0) and then the x and_y positions in_the grid object move_to the next cell. (as part of the get and_set methods)

A:

x and y are the 'current position' members of the Class Grid.

I don't see a bug_in the_code snippet but this_statement raises_a_Big Red Flag.  The grid_doesn't have_a current position, only a Cell does. _You_cannot keep track of the 'next.Cell' state for the grid, it must_be_computed_for each individual_cell._ The next grid is created_from_the_new_cells_after evaluating all the grid positions._ Or use two grids and swap_them.

_Q:

Why don't researchers publish failed_experiments?

The following_might_be a slight generalization_for all fields but_something I've noticed especially in the field of Scientific Computing:

Why don't_people_publish failures?_I_mean,_if_they tried some experiment_and realized at the end that they tried everything and nothing worked. Why don't they_publish_this?