void stop_state_fn(){
if (just_entered_state){
Serial.println("stop_state_fn");
}
if (respond_to_key(NULL_STATE)) return;
}
void rotating_left_fn(){
if (just_entered_state){
debug_red->led_on();
debug_blue->led_on();
Serial.println("rotating_left_fn");
start_timer(MAIN_STATE_TIMER, 2000);
rotate_left(10);
}
if (respond_to_key(MOVING_FORWARD)) return;
if (respond_to_timer(MAIN_STATE_TIMER, ROTATING_RIGHT)) return;
}
void moving_backward_fn(){
if (just_entered_state){
debug_green->led_on();
Serial.println("moving_backward_fn");
start_timer(MAIN_STATE_TIMER, 2000);
move_backwards(2);
// move_forwards(5);
}
if (respond_to_key(ROTATING_LEFT)) return;
if (respond_to_timer(MAIN_STATE_TIMER, NULL_STATE));
}
void retracting_button_presser_fn(){
if (just_entered_state){
Serial.println("retracting_button_presser_fn");
//move servo back a bit
debug_blue->led_on();
retract_button_presser();
start_timer(SERVO_TIMER, BUTTON_PRESSER_DELAY);
}
// if (respond_to_enough_presses(3,STRAIGHT_BACK_TO_DEPO)) return;
unsigned char coins_to_get = coins_for_exchanges[coin_collection_round];
if (respond_to_enough_presses(coins_to_get,WAIT_FOR_LAST_COIN)) return;
if (respond_to_key(RETRACTING_BUTTON_PRESSER)) return;
if (respond_to_timer(SERVO_TIMER, EXTENDING_BUTTON_PRESSER)) return;
// if (respond_to_timer(SERVO_TIMER, NULL_STATE)) return;
// if (respond_to_timer(SERVO_TIMER, RETRACTING_BUTTON_PRESSER)) return;
// if (respond_to_button_presser_finished(EXTENDING_BUTTON_PRESSER)) return;
}
void extending_button_presser_fn(){
if (just_entered_state){
Serial.println("extending_button_presser_fn");
extend_button_presser();
debug_green->led_on();
start_timer(SERVO_TIMER, BUTTON_PRESSER_DELAY);
pulse_forward();
// set servo timer
}
check_pulse();
// reenter the state and reincrement the servo
if (respond_to_key(EXTENDING_BUTTON_PRESSER)) return;
if (respond_to_timer(SERVO_TIMER, RETRACTING_BUTTON_PRESSER)) return; // uhh...
// if (respond_to_timer(SERVO_TIMER, EXTENDING_BUTTON_PRESSER)) return;
// if (respond_to_button_presser_finished(RETRACTING_BUTTON_PRESSER)) return;
}
bool
RoxorCore::respond_to(VALUE obj, VALUE klass, SEL sel, bool priv,
bool check_override)
{
if (klass == Qnil) {
klass = CLASS_OF(obj);
}
else {
assert(!check_override);
}
IMP imp = NULL;
const bool overriden = check_override
? ((imp = class_getMethodImplementation((Class)klass, selRespondTo))
!= basic_respond_to_imp)
: false;
if (!overriden) {
lock();
const long key = respond_to_key((Class)klass, sel);
std::map<long, int>::iterator iter = respond_to_cache.find(key);
int iter_cached = (iter != respond_to_cache.end());
unlock();
int status;
if (iter_cached) {
status = iter->second;
}
else {
Method m = class_getInstanceMethod((Class)klass, sel);
if (m == NULL) {
const char *selname = sel_getName(sel);
sel = helper_sel(selname, strlen(selname));
if (sel != NULL) {
m = class_getInstanceMethod((Class)klass, sel);
}
}
IMP imp = method_getImplementation(m);
if (UNAVAILABLE_IMP(imp) || imp == (IMP)rb_f_notimplement) {
status = RESPOND_TO_NOT_EXIST;
}
else {
rb_vm_method_node_t *node = method_node_get(m);
if (node != NULL && (node->flags & VM_METHOD_PRIVATE)) {
status = RESPOND_TO_PRIVATE;
}
else {
status = RESPOND_TO_PUBLIC;
}
}
lock();
respond_to_cache[key] = status;
unlock();
}
return status == RESPOND_TO_PUBLIC
|| (priv && status == RESPOND_TO_PRIVATE);
}
else {
if (imp == NULL || imp == _objc_msgForward) {
// The class does not respond to respond_to?:, it's probably
// NSProxy-based.
return false;
}
VALUE args[2];
int n = 0;
args[n++] = ID2SYM(rb_intern(sel_getName(sel)));
if (priv) {
rb_vm_method_node_t *node = method_node_get(imp);
if (node != NULL
&& (2 < node->arity.min
|| (node->arity.max != -1 && 2 > node->arity.max))) {
// Do nothing, custom respond_to? method incompatible arity.
}
else {
args[n++] = Qtrue;
}
}
return rb_vm_call(obj, selRespondTo, n, args) == Qtrue;
}
}
