SFBReactor.h

Go to the documentation of this file.

/*                                       -*- mode:C++; fill-column: 100 -*-
  SFBReactor.h - Register packet handlers and dispatch packets
  Copyright (C) 2009 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 SFBREACTOR_H_
#define SFBREACTOR_H_

#include "SFBTypes.h"
#include "SFBAssert.h"

typedef void (*PacketHandler)(u8 * packet) ;

typedef void (*DispatchHandler)(u8 * packet, u8 face);

struct GRL {
  u8 tableIndex;
  u8 entryIndex;
};
extern bool isNone(GRL g) ;
extern GRL makeGRL(u8 table, u8 entry) ;
extern void initGRL(GRL & g, u8 table = 0, u8 entry = 0) ;

#define MAX_GRL_TABLES 7

struct SFBGRLMasterTable {
  const PacketHandler *(tables[MAX_GRL_TABLES]);
  u8 lengths[MAX_GRL_TABLES];
  u8 inUse;

  SFBGRLMasterTable() ;
  u8 addTable(const PacketHandler * table, int length) ;

  GRL find(PacketHandler ph) ;

  PacketHandler find(GRL index) ;
};

#define MAX_REACTORS 200

struct SFBDispatchEntry {
  SFBDispatchEntry() ;
  GRL grl;
  u8 type;
  u8 flags;
};
#define MAX_CASUAL_REFLEXES 10 

#define TRIGGER_SET_TYPE s16
#define MAX_NESTED_TRIGGERS (sizeof(TRIGGER_SET_TYPE)*8)

class SFBReactor {

  // The partitions
  enum {
    END_PARTITION=BRAIN+1,
    PARTITION_COUNT
  };
  int nextPartition(int partition) ;

  int partitionLength(const u8 partition) ;
  bool inPartition(const u8 partition, const u8 type);
  void openUp(const u8 inPartition, const u8 atPosition);
  void addToPartition(const u8 partition, const u8 type, GRL grl, u8 flags);

  GRL addToCasual(PacketHandler ph) ;

  GRL findOrAdd(PacketHandler ph) ;

public:

  enum { 
    TRIGGER_IF_BROKEN  = 0x01,  
    TRIGGER_EMPTY =      0x02,  
    TRIGGER_SUPPRESSED = 0x04,  
    TRIGGER_RESERVED3 =  0x08,  
    TRIGGER_RESERVED4 =  0x10,  
    TRIGGER_RESERVED5 =  0x20,  
    TRIGGER_RESERVED6 =  0x40,  
    TRIGGER_RESERVED7 =  0x80,  
    // The rest of these triggers are not stored in the flags: Instead
    // they determine which partition(s) the reflex is in.
    TRIGGER_FIRST_PARTITION = 0x100,
    TRIGGER_NORTH =  TRIGGER_FIRST_PARTITION<<NORTH, 
    TRIGGER_SOUTH =  TRIGGER_FIRST_PARTITION<<SOUTH, 
    TRIGGER_EAST =   TRIGGER_FIRST_PARTITION<<EAST,  
    TRIGGER_WEST =   TRIGGER_FIRST_PARTITION<<WEST,  
    TRIGGER_SPINE =  TRIGGER_FIRST_PARTITION<<SPINE, 
    TRIGGER_MEMORY = TRIGGER_FIRST_PARTITION<<WMEM,  
    TRIGGER_BRAIN =  TRIGGER_FIRST_PARTITION<<BRAIN, 
    TRIGGER_ALL_PARTITIONS =
      TRIGGER_NORTH|TRIGGER_SOUTH|TRIGGER_EAST|TRIGGER_WEST|TRIGGER_SPINE|TRIGGER_MEMORY|TRIGGER_BRAIN
  };

  void reset() ;

  int faceToFlag(const u32 face) ;

  u8 reflexes(const PacketHandler * table, int length) ;

  void reflex(const char type, PacketHandler pfunc, int partitions = TRIGGER_SPINE, bool ifBroken = false) ;

  void reflexReflex(const char type, PacketHandler pfunc, int partitions = TRIGGER_SPINE, bool ifBroken = false) ;

  void implReflex(const char type, PacketHandler pfunc, int partitions = TRIGGER_SPINE, bool ifBroken = false) ;

  bool reflexExists(const char type, int partitions = TRIGGER_ALL_PARTITIONS) ;

  void suppress(const char type, int partitions);  /* No default on partitions, you have to say.. */
  void allow(const char type, int partitions);  /* No default on partitions, you have to say.. */

  void otherwise(PacketHandler pfunc, int partitions = TRIGGER_BRAIN, bool allowBroken = false) ;

  void empty(PacketHandler pfunc, int partitions = TRIGGER_SPINE, bool allowBroken = false) ;

  void triggerUp() ;

  bool inHandler() ;

  u8 source() ;

  u8 getFlags(const char type) ;

  void trigger(u8 * packet, u8 face) ;

  SFBReactor() ;

  bool canTrigger() ;

private:

  void setSpecial(const u8 offset, u8 flags, GRL grl, int partitions) ;

  bool fireTrigger(u8 * packet, PacketHandler ph, u8 face) ;

  int positionInPartition(const u8 partition, const u8 type) ;

  GRL findInPartitions(const u8 type, int flags) ;


  SFBGRLMasterTable masterTable;
  SFBDispatchEntry entries[MAX_REACTORS];
  PacketHandler casualTable[MAX_CASUAL_REFLEXES];
  u16 partitionStarts[PARTITION_COUNT];
  u8 casualTableInUse;

  u8 triggerSources[MAX_NESTED_TRIGGERS];
  TRIGGER_SET_TYPE triggerUpFlags;
  s8 topTrigger;

  friend void reflex(const char type, PacketHandler ph, int flags);
};

void reflex(const char type, PacketHandler ph, int flags = SFBReactor::TRIGGER_SPINE);

extern SFBReactor Body;

class SFBBrainReflex {
 public:
  void reflex(const char type, PacketHandler ph) {
    ::reflex(type, ph, SFBReactor::TRIGGER_BRAIN);
  }
};
extern SFBBrainReflex Brain;

class SFBSpineReflex {
 public:
  void reflex(const char type, PacketHandler ph) {
    ::reflex(type, ph, SFBReactor::TRIGGER_SPINE);
  }
};
extern SFBSpineReflex Spine;

#endif /* SFBREACTOR_H_ */