Grid.h

Go to the documentation of this file.

/*                                              -*- mode:C++ -*-
  Grid.h Encapsulator for all MFM logic
  Copyright (C) 2014 The Regents of the University of New Mexico.  All rights reserved.

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
  USA
*/

#ifndef GRID_H
#define GRID_H

#include "itype.h"
#include "Tile.h"
#include "ElementTable.h"
#include "Random.h"
#include "GridConfig.h"
#include "ElementRegistry.h"
#include "Logger.h"

#include "Element_Wall.h"

namespace MFM {

  template <class GC>
  class Grid
  {
    // Extract short type names
    typedef typename GC::CORE_CONFIG CC;
    typedef typename CC::ATOM_TYPE T;
    typedef typename CC::PARAM_CONFIG P;
    enum { W = GC::GRID_WIDTH};
    enum { H = GC::GRID_HEIGHT};
    enum { R = P::EVENT_WINDOW_RADIUS};

  private:
    Random m_random;

    u32 m_seed;

    void ReinitSeed();

    const u32 m_width, m_height;

    SPoint m_lastEventTile;

    Tile<CC> m_tiles[W][H];

    bool m_backgroundRadiationEnabled;

    ElementRegistry<CC> m_er;

    s32 m_xraySiteOdds;

    u8 m_gridGeneration;

    bool m_ignoreThreadingProblems;

    struct TileControl
    {
      virtual const char * GetName() = 0;

      virtual void MakeRequest(Tile<CC> &) = 0;
      virtual bool CheckIfReady(Tile<CC> &) = 0;
      virtual void Execute(Tile<CC> &) = 0;

    };

    struct PauseControl : public TileControl
    {
      virtual const char * GetName()
      {
        return "Pause";
      }

      virtual void MakeRequest(Tile<CC> & tile)
      {
        tile.RequestPause();
      }
      virtual bool CheckIfReady(Tile<CC> & tile)
      {
        return tile.IsPauseReady();
      }
      virtual void Execute(Tile<CC> & tile)
      {
        tile.Pause();
      }
    };

    struct RunControl : public TileControl
    {
      virtual const char * GetName()
      {
        return "Unpause";
      }

      virtual void MakeRequest(Tile<CC> & tile)
      {
        tile.Start();
      }
      virtual bool CheckIfReady(Tile<CC> & tile)
      {
        return tile.IsRunReady();
      }
      virtual void Execute(Tile<CC> & tile)
      {
        tile.Run();
      }
    };

    void DoTileControl(TileControl & tc);

  public:
    void ReportGridStatus(Logger::Level level) ;

    Random& GetRandom() { return m_random; }

    bool* GetBackgroundRadiationEnabledPointer()
    {
      return &m_backgroundRadiationEnabled;
    }

    friend class GridRenderer;

    void SetSeed(u32 seed);

    Grid(ElementRegistry<CC>& elts) :
      m_seed(0),
      m_width(W),
      m_height(H),
      m_er(elts),
      m_xraySiteOdds(1000),
      m_gridGeneration(0),
      m_ignoreThreadingProblems(false)
    {
      for (u32 y = 0; y < H; ++y)
      {
        for (u32 x = 0; x < W; ++x)
        {
          LOG.Debug("Tile[%d][%d] @ %p", x, y, &m_tiles[x][y]);
        }
      }
    }

    void SetIgnoreThreadingProblems(bool value)
    {
      m_ignoreThreadingProblems = value;
      for(u32 x = 0; x < W; x++)
      {
        for(u32 y = 0; y < H; y++)
        {
          GetTile(x, y).SetIgnoreThreadingProblems(value);
        }
      }
    }

    s32* GetXraySiteOddsPtr()
    {
      return &m_xraySiteOdds;
    }

    void Reinit();

    const Element<CC> * LookupElement(u32 elementType) const
    {
      return m_tiles[0][0].GetElementTable().Lookup(elementType);
    }

    ElementRegistry<CC>& GetElementRegistry()
    {
      return m_er;
    }

    void Needed(Element<CC> & anElement)
    {
      anElement.AllocateType();         // Force a type now
      m_er.RegisterElement(anElement);  // Make sure we're in here (How could we not?)

      for(u32 i = 0; i < W; i++)
      {
        for(u32 j = 0; j < H; j++)
        {
          m_tiles[i][j].RegisterElement(anElement);
        }
      }
      LOG.Message("Assigned type 0x%04x for %@",anElement.GetType(),&anElement.GetUUID());
    }

    template <typename PointerType> class MyIterator
    {
      Grid & g;
      s32 i;
      s32 j;
    public:
      MyIterator(Grid<GC> & g, int i = 0, int j = 0) : g(g), i(i), j(j) { }

      bool operator!=(const MyIterator &m) const { return i != m.i || j != m.j; }
      void operator++()
      {
        if (j < g.H)
        {
          i++;
          if (i >= g.W)
          {
            i = 0;
            j++;
          }
        }
      }
      int operator-(const MyIterator &m) const
      {
        s32 rows = j-m.j;
        s32 cols = i-m.i;
        return rows*g.W + cols;
      }

      PointerType operator*() const
      {
        return &g.m_tiles[i][j];
      }
    };

    typedef MyIterator<Tile<CC>*> iterator_type;
    typedef MyIterator<const Tile<CC>*> const_iterator_type;

    iterator_type begin() { return iterator_type(*this); }

    const_iterator_type begin() const { return iterator_type(*this); }

    iterator_type end() { return iterator_type(*this,0,H); }

    const_iterator_type end() const { return const_iterator_type(*this, 0,H); }

    ~Grid()
    { }

    void SetTileToExecuteOnly(const SPoint& tileLoc, bool value);

    bool GetTileExecutionStatus(const SPoint& tileLoc);

    void EmptyTile(const SPoint& tileLoc)
    {
      Tile<CC> & tile = GetTile(tileLoc);
      tile.ClearAtoms();
      tile.SetGeneration(m_gridGeneration);
    }

    void Clear();

    void CheckCaches();

    bool IsLegalTileIndex(const SPoint & tileInGrid) const;

    bool MapGridToTile(const SPoint & siteInGrid, SPoint & tileInGrid, SPoint & siteInTile) const;

    bool MapGridToUncachedTile(const SPoint & siteInGrid, SPoint & tileInGrid, SPoint & siteInTile) const;

    static u32 GetHeight() { return H; }

    static u32 GetWidth() { return W; }

    static u32 GetHeightSites()
    {
      return GetHeight() * Tile<CC>::OWNED_SIDE;
    }

    static u32 GetWidthSites()
    {
      return GetWidth() * Tile<CC>::OWNED_SIDE;
    }

    void Pause()
    {
      PauseControl pc;
      DoTileControl(pc);
    }

    void Unpause()
    {
      RunControl rc;
      DoTileControl(rc);
    }

    void RecountAtoms();

    void PlaceAtom(const T& atom, const SPoint& location);

    void XRayAtom(const SPoint& location);

    void MaybeXRayAtom(const SPoint& location);

    const T* GetAtom(SPoint& loc)
    {
      SPoint tileInGrid, siteInTile;
      if (!MapGridToTile(loc, tileInGrid, siteInTile))
      {
        LOG.Error("Can't get atom at site (%d,%d): Does not map to grid.",
                  loc.GetX(), loc.GetY());
        FAIL(ILLEGAL_ARGUMENT);  // XXX Change to return bool?
      }
      return GetTile(tileInGrid).GetAtom(siteInTile);
    }

    T* GetWritableAtom(SPoint& loc)
    {
      SPoint tileInGrid, siteInTile;
      if (!MapGridToTile(loc, tileInGrid, siteInTile))
      {
        return NULL;
      }
      return GetTile(tileInGrid).GetWritableAtom(siteInTile);
    }

    void FillLastEventTile(SPoint& out);

    inline Tile<CC> & GetTile(const SPoint& pt)
    {return GetTile(pt.GetX(), pt.GetY());}

    inline const Tile<CC> & GetTile(const SPoint& pt) const
    {return GetTile(pt.GetX(), pt.GetY());}

    inline Tile<CC> & GetTile(u32 x, u32 y)
    { return m_tiles[x][y]; }

    inline const Tile<CC> & GetTile(u32 x, u32 y) const
    { return m_tiles[x][y]; }

    /* Don't count caches! */
    static inline const u32 GetTotalSites()
    { return GetWidthSites() * GetHeightSites(); }

    u64 GetTotalEventsExecuted() const;

    void WriteEPSImage(ByteSink & outstrm) const;

    void WriteEPSAverageImage(ByteSink & outstrm) const;

    void ResetEPSCounts();

    u32 GetAtomCount(ElementType atomType) const;

    double GetEmptySitePercentage() const
    {
      return 1.0 - ((double)GetAtomCount(Element_Empty<CC>::THE_INSTANCE.GetType()) /
                    (double)(GetHeightSites() * GetWidthSites()));
    }

    void SurroundRectangleWithWall(s32 x, s32 y, s32 w, s32 h, s32 thickness);

    void RandomNuke();

    void SetBackgroundRadiation(bool value);

    void ToggleBackgroundRadiation()
    {
      SetBackgroundRadiation(!m_backgroundRadiationEnabled);
    }

    bool IsBackgroundRadiataionEnabled()
    {
      return m_backgroundRadiationEnabled;
    }

    void XRay();

    u32 CountActiveSites() const;
  };
} /* namespace MFM */

#include "Grid.tcc"

#endif /*GRID_H*/