示例#1
0
文件: matrix.c 项目: emdete/pentabug
void matrix_show(void) {
    for(uint8_t n = 0; n < 4; ++n) {
        uint8_t i;

        for(i = 0; i < 3; ++i) {
            move_line(i);
            write_line(pixels + (i * 3), n);
            wait_ms(1);
        }
    }
}
示例#2
0
文件: matrix.c 项目: emdete/pentabug
static void matrix_int(void) {
    ++index;

    if(index >= 3) {
        ++cycle;
        index = 0;
    }

    move_line(index);
    write_line(pixels + (index * 3), cycle & 3);
}
示例#3
0
void move_primitive(PRIMITIVE *p)
{
    switch (p->size)
    {
        case 1:
            move_point(&p->points[0], p->velocity);
            break;
        case 2:
            move_line(&p->points[0], &p->points[1], &p->centroid, p->velocity, p->rotation);
            break;
        default:
            move_polygon(p->points, p->size, &p->centroid, p->velocity, &p->angle, p->rotation, &p->bounding_box);
            break;
    }
}
示例#4
0
文件: route.c 项目: crooney/chex
bool route(int ch)
{
    /* Keys available in both ESCAPE and REPLACE modes. */
    switch (ch) {
    case CTRL('c'):
    case CTRL('q'):
        return false;
        break;
    case KEY_SUSPEND:
    case CTRL('z'):
        suspend();
        break;
    case CTRL('w'):
        buf_write();
        break;
    case CTRL('r'):
        buf_revert();
        break;
    case CTRL('['):
        set_state(ESCAPE);
        break;
    case KEY_LEFT:
        move_col(-1);
        break;
    case KEY_UP:
        move_line(-1);
        break;
    case KEY_RIGHT:
        move_col(+1);
        break;
    case KEY_DOWN:
        move_line(+1);
        break;
    case '\t':
        toggle_mode();
        break;
    default:
        if (buf.state == REPLACE) {
            replace_char(ch);
            return true;
        }
        break;
    }

    /* Keys available in only ESCAPE mode. */
    switch (ch) {
    case 'R':
        set_state(REPLACE);
        break;
    case 'h':
        move_col(-1);
        break;
    case 'k':
        move_line(-1);
        break;
    case 'l':
        move_col(+1);
        break;
    case 'j':
        move_line(+1);
        break;
    case 'w':
        goto_grp_next();
        break;
    case 'b':
        goto_grp_prev();
        break;
    case 'g':
        goto_buffer_beg();
        break;
    case 'G':
        goto_buffer_end();
        break;
    case '^':
        goto_line_beg();
        break;
    case '$':
        goto_line_end();
        break;
    case 'd':
        goto_half_next();
        break;
    case 'u':
        goto_half_prev();
        break;
    case '?':
        view.help = !view.help;
        break;
    default:
        break;
    }

    return true;
}
示例#5
0
	bool Stinkhorn<CellT, Dimensions>::ToysFingerprint::handleInstruction(CellT instruction, Context& ctx) {
		StackStackT& stack = ctx.stack();
		Cursor& cr = ctx.cursor();

		switch(instruction) {
			case 'C':
				copy(ctx, true, false);
				return true;

			case 'K':
				copy(ctx, false, false);
				return true;

			case 'M':
				copy(ctx, true, true);
				return true;

			case 'V':
				copy(ctx, false, true);
				return true;

			case 'S':
				chicane(ctx);
				return true;

			case 'L':
				{
					stack.push(cr.get(cr.position() + cr.leftwards90Z()));
					return true;
				}

			case 'R': 
				{
					stack.push(cr.get(cr.position() + cr.rightwards90Z()));
					return true;
				}

			case 'I':
				stack.push(stack.pop() + 1);
				return true;

			case 'D':
				stack.push(stack.pop() - 1);
				return true;

			case 'N':
				stack.push(-stack.pop());
				return true;

			//SPEC: I'm assuming it's meant to push a back onto the stack, even though
			//the documentation didn't say so.
			case 'H':
				{
					CellT a, b;
					b = stack.pop();
					a = stack.pop();
					if(b >= 0)
						a <<= b;
					else
						a >>= -b;
					stack.push(a);
					return true;
				}

			case 'A':
				{
					CellT n = stack.pop();
					CellT value = stack.pop();
					if(n < 0)
						cr.reflect();
					else
						while(n--)
							stack.push(value);
					return true;
				}

			case 'B':
				{
					CellT a, b;
					b = stack.pop();
					a = stack.pop();
					stack.push(a+b);
					stack.push(a-b);
					return true;
				}

			case 'E':
				{
					CellT sum = 0;
					while(stack.topStackSize())
						sum += stack.pop();
					stack.push(sum);
					return true;
				}

			case 'P':
				{
					CellT sum = 1;
					while(stack.topStackSize())
						sum *= stack.pop();
					stack.push(sum);
					return true;
				}

			//SPEC: I interpreted the spec as saying that j should be implicitly taken from 
			//the size of the stack... but what do I know?
			//Doing what ccbi does here anyway.
			case 'F':
				{
					Vector least = stack.popVector(Dimensions);
					Cursor matrix_cursor(cr);
					CellT j = stack.pop();
					CellT i = stack.pop();
					if(i <= 0) {
						cr.reflect();
						return true;
					}

					CellT y = 0;
					while(y < j) { 
						for(CellT x = 0; x < i; ++x) {
							matrix_cursor.position(least + Vector(x, y, 0));
							matrix_cursor.put(matrix_cursor.position(), stack.pop());
						}
						++y;
					}

					return true;
				}

				//SPEC: Location of j chosen for compatibility with ccbi
				//(Obviously, j can't be implicit here, unless you terminated on an empty row, but that
				//would be silly)
			case 'G':
				{
					Vector least = stack.popVector(Dimensions);
					Cursor matrix_cursor(cr);
					CellT j = stack.pop();
					CellT i = stack.pop();
					if(i <= 0) {
						cr.reflect();
						return true;
					}

					//SPEC: CCBI does it this way (ie., backwards so that F then G preserves the stack), 
					//but it seems undefined to me.
					for(CellT y = j - 1; y >= 0; --y) {
						for(CellT x = i - 1; x >= 0; --x) {
							matrix_cursor.position(least + Vector(x, y, 0));
							stack.push(matrix_cursor.currentCharacter());
						}
					}

					return true;
				}

			case 'Q':
				cr.put(cr.position() - cr.direction(), stack.pop());
				return true;

			//SPEC: TODO: These should respect hover mode, once it's here...
			case 'T': 
				{
					CellT d = stack.pop();
					Vector current;
					/*if(hover)
						current = cr.direction();*/
					switch(d) {
						case 0: cr.direction(current + (stack.pop() ? Vector(-1, 0, 0) : Vector(1, 0, 0))); break;
						case 1: cr.direction(current + (stack.pop() ? Vector(0, -1, 0) : Vector(0, 1, 0))); break;
						case 2: 
							if(Dimensions > 2)
								cr.direction(current + (stack.pop() ? Vector(0, 0, 1) : Vector(0, 0, -1)));
							else
								cr.reflect();
							break;
						default:
							cr.reflect();
					}

					return true;
				}

				//TODO: Low bits of rand() are the least reliable... Should be changed?
			case 'U':
				{
					assert(Dimensions <= 3);
					CellT result = "<>^vhl"[rand() % (Dimensions * 2)];
					cr.put(cr.position(), result);
					return true;
				}

			case 'W':
				{
					Vector pos = stack.popVector(Dimensions);
					CellT value = stack.pop();
					CellT actual = cr.get(pos + ctx.storageOffset());
					if(actual < value) {
						stack.push(value);

						if(Dimensions > 2)
							stack.push(pos.z);
						stack.push(pos.y);
						stack.push(pos.x);

						cr.position(cr.position() - cr.direction());
					} else if(actual > value) {
						cr.reflect();
					}
					return true;
				}

			case 'X':
				cr.position(cr.position() + Vector(1, 0, 0));
				return true;
				
			case 'Y':
				cr.position(cr.position() + Vector(0, 1, 0));
				return true;

			case 'Z':
				if(Dimensions > 2)
					cr.position(cr.position() + Vector(0, 0, 1));
				else
					cr.reflect();
				return true;

			case 'O': case 'J': 
				{
					CellT delta = stack.pop();
					if (delta == 0)
						return true;

					CellT d = delta > 0 ? 1 : -1;
					move_line(ctx, instruction == 'O' ? Vector(d, 0, 0) : Vector(0, d, 0), abs(delta));
					return true;
				}
		}

		return false;
	}
示例#6
0
/* ------------------------ */
button_click()
{
register int object;

/*		'TOP LINE': oberste Begrenzung aller Zeichen.						*/
/* 'ASCENT LINE': oberste Zeile aller Gro�buchstaben					 */
/*	 'HALF LINE': oberste Zeile aller Kleinbuchstaben 				 */
/*	 'BASE LINE': unterste Zeile aller Zeichen ohne Unterl�nge */
/*'DESCENT LINE': unterste Zeile aller Zeichen mit Unterl�ngen */
/* 'BOTTOM LINE': unterste Begrenzung aller Zeichen.					 */

object = objc_find(font_back, ROOT, MAX_DEPTH, mousex, mousey);
switch(object)
	{
	case TOP:
	case ASCENT:
	case HALF:
	case BASE:
	case BOTTOM:
	case DESCENT:
	 	if (clicks == 1 && object != TOP)
			move_line(object);
		else
			switch(object)
				{
			  case TOP:
					form_alert(1, "[1]['TOP LINE':| |oberste Begrenzung aller |Zeichen.][ OK ]");
					break;

			  case ASCENT:
					form_alert(1, "[1]['ASCENT LINE':| |oberste Zeile aller |Gro�buchstaben.][ OK ]");
					break;

				case HALF:
					form_alert(1, "[1]['HALF LINE':| |oberste Zeile aller |Kleinbuchstaben.][ OK ]");
					break;

				case BASE:
					form_alert(1, "[1]['BASE LINE':| |unterste Zeile aller |Zeichen ohne Unterl�nge][ OK ]");
					break;

				case BOTTOM:
					form_alert(1, "[1]['BOTTOM LINE':| |unterste Begrenzung |aller Zeichen.][ OK ]");
					break;

				case DESCENT:
					form_alert(1, "[1]['DESCENT LINE':| |unterste Zeile aller |Zeichen mit Unterl�ngen.][ OK ]");
					break;
				}

		break;

	case F_BKG: 												/* Editierfeld */
		draw_fpoint();
		break;

	case SCL_RGT: 											/* Skala rechts */
		scale_right();
		break;

	case SCL_LFT: 											/* Skala links */
		scale_left();
		break;

	case ROOT:													/* Hintergrund */
		break;

	case FONTNAME:											/* Fontname */
		edit_name();
		break;

	case UP:														/* Editorzeile hoch */
		edit_up();
		break;					

	case DOWN:													/* Editorzeile runter */
		edit_dwn();		
		break;

	case LEFT:													/* Editorspalte links */
		edit_lft();
		break;
		
	case RIGHT:													/* Editorspalte rechts */
		edit_rgt();
		break;
				
	default:														/* FONTLINE */
		new_character();
		break;
	}
}