Exemple #1
0
func main() {
	//
	if !scr.MouseEx() {
		return
	}
	var symbol [Nfigure]byte
	symbol[line] = 'S'      // "Strecke"
	symbol[rectangle] = 'R' // "Rechteck"
	symbol[circle] = 'K'    // "Kreis"
	symbol[ellipse] = 'E'   // "Ellipse"
	X, Y := 0, 0
	X1, Y1 := scr.NX(), scr.NY()
	//  Farbe, Papier:= col.LightWhite, col.Black
	Farbe, Papier := col.Black, col.LightWhite
	col.ScreenF, col.ScreenB = Farbe, Papier
	scr.Cls()
	paintColour := Farbe
	scr.Colour(paintColour)
	//  Staerke = 3
	bx := box.New()
	bx.Wd(20)
	bx.Colours(Papier, Farbe)
	Name := env.Par(1)
	if str.Empty(Name) {
		Name = "temp"
	}
	scr.Save(0, 0, 20, 1)
	for {
		bx.Edit(&Name, 0, 0)
		if !str.Empty(Name) {
			str.RemSpaces(&Name)
			break
		}
	}
	scr.Restore(0, 0, 20, 1)
	img.Get(Name, uint(X), uint(Y))
	scr.MouseCursor(true)
	Figur := figure(rectangle)
	var x, y, x0, y0 int
loop:
	for {
		scr.Colour(paintColour)
		Zeichen, Kommando, T := kbd.Read()
		switch Kommando {
		case kbd.None:
			x, y = scr.MousePosGr()
			scr.SwitchTransparence(true)
			scr.Write1Gr(Zeichen, x, y-int(scr.NY1()))
			//    scr.WarpMouse (x + scr.NX1(), y)
		case kbd.Esc:
			break loop
		case kbd.Back:
			switch T {
			case 0:
				x, y = scr.MousePosGr()
				x -= int(scr.NX1())
				scr.Colour(Papier)
				scr.Write1Gr(' ', x, y-int(scr.NY1()))
				//        scr.RectangleFull (x, y - scr.NY1(), x + scr.NX1(), y)
				//        scr.WarpMouseGr (x, y)
				scr.Colour(paintColour)
			default:
				scr.Cls()
			}
			/*
			   case kbd.Ins:
			     img.Write (X, Y, X1, Y1 - 16, Name)
			     box.Edit (Feld, Name, scr.Zeilenzahl () - 1, 0)
			     img.Get (X, Y, Name)
			*/
		case kbd.Help:
			paintColour = sel.Colour()
			//    case kbd.LookFor:
			//      Staerke = Strichstaerken.Staerke()
		case kbd.Enter:
			if T > 0 {
				x0, y0 = scr.MousePosGr()
				//        scr.Fill1 (x0, y0)
			}
		case kbd.PrintScr:
			img.Print(uint(X), uint(Y), X1, Y1-16)
		case kbd.Tab:
			if T == 0 {
				if Figur+1 < Nfigure {
					Figur++
				} else {
					Figur = figure(0)
				}
			} else {
				if Figur > 0 {
					Figur--
				} else {
					Figur = figure(Nfigure - 1)
				}
			}
			scr.Colours(col.White, Papier)
			scr.Write1(symbol[Figur], scr.NY()-1, 0)
		case kbd.Here:
			x0, y0 = scr.MousePosGr()
			scr.CircleFull(x0, y0, 3/2)
		case kbd.Pull:
			x, y = scr.MousePosGr()
			scr.Line(x0, y0, x, y)
			x0, y0 = x, y
		case kbd.Hither:
			x, y = scr.MousePosGr()
			scr.Line(x0, y0, x, y)
		case kbd.There:
			x0, y0 = scr.MousePosGr()
			x, y = x0, y0
		case kbd.Push:
			paint(Figur, inv, x0, y0, x, y)
			x, y = scr.MousePosGr()
			paint(Figur, inv, x0, y0, x, y)
		case kbd.Thither:
			paint(Figur, inv, x0, y0, x, y)
			//      scr.Colour (paintColour)
			x, y = scr.MousePosGr()
			paint(Figur, border, x0, y0, x, y)
			x0, y0 = x, y
		case kbd.This:
			x0, y0 = scr.MousePosGr()
			x, y = x0, y0
		case kbd.Move:
			scr.LineInv(x0, y0, x, y)
			x, y = scr.MousePosGr()
			scr.LineInv(x0, y0, x, y)
		case kbd.Thus:
			scr.LineInv(x0, y0, x, y)
			x, y = scr.MousePosGr()
			scr.Line(x0, y0, x, y)
			x0, y0 = x, y
		}
	}
	scr.Save(0, 0, 20, 1)
	for {
		bx.Edit(&Name, 0, 0)
		// TODO make sure, that "Name" is x{x|y} where x is letter, y is digit
		if !str.Empty(Name) {
			str.RemSpaces(&Name)
			break
		}
	}
	scr.Restore(0, 0, 20, 1)
	img.Put(Name, uint(X), uint(Y), X1, Y1)
	ker.Terminate()
}
Exemple #2
0
func (R *Imp) Manipulieren(K kbd.Comm, T uint) {
	//
	s := schrittweise
	schrittweise = false
	amEditieren = true
	switch K {
	case kbd.Esc:
		return
	case kbd.Enter:
		if T == 0 {
			if R.Geschoben1() {
			}
		} else {
			R.schiessen()
		}
	case kbd.Left:
		if Sokoban {
			switch R.richtung {
			case Nord:
				R.LinksDrehen()
			case West:

			case Sued:
				R.RechtsDrehen()
			case Ost:
				R.umkehren()
			}
			if R.NachbarLeer() {
				if R.Gelaufen1() {
				}
			} else {
				if R.Geschoben1() {
				}
			}
		} else {
			switch R.richtung {
			case Nord:
				R.LinksDrehen()
			case West:
				if T == 0 {
					if R.Gelaufen1() {
					}
				} else {
					for R.Gelaufen1() {
					}
				}
			case Sued:
				R.RechtsDrehen()
			case Ost:
				R.umkehren()
			}
		}
	case kbd.Right:
		if Sokoban {
			switch R.richtung {
			case Nord:
				R.RechtsDrehen()
			case West:
				R.umkehren()
			case Sued:
				R.LinksDrehen()
			case Ost:

			}
			if R.NachbarLeer() {
				if R.Gelaufen1() {
				}
			} else {
				if R.Geschoben1() {
				}
			}
		} else {
			switch R.richtung {
			case Nord:
				R.RechtsDrehen()
			case West:
				R.umkehren()
			case Sued:
				R.LinksDrehen()
			case Ost:
				if T == 0 {
					if R.Gelaufen1() {
					}
				} else {
					for R.Gelaufen1() {
					}
				}
			}
		}
	case kbd.Up:
		if Sokoban {
			switch R.richtung {
			case Nord:

			case West:
				R.RechtsDrehen()
			case Sued:
				R.umkehren()
			case Ost:
				R.LinksDrehen()
			}
			if R.NachbarLeer() {
				if R.Gelaufen1() {
				}
			} else {
				if R.Geschoben1() {
				}
			}
		} else {
			if T == 2 {
				R.Entmarkieren()
			} else {
				switch R.richtung {
				case Nord:
					if T == 0 {
						if R.Gelaufen1() {
						}
					} else {
						for R.Gelaufen1() {
						}
					}
				case West:
					R.RechtsDrehen()
				case Sued:
					R.umkehren()
				case Ost:
					R.LinksDrehen()
				}
			}
		}
	case kbd.Down:
		if Sokoban {
			switch R.richtung {
			case Nord:
				R.umkehren()
			case West:
				R.LinksDrehen()
			case Sued:

			case Ost:
				R.RechtsDrehen()
			}
			if R.NachbarLeer() {
				if R.Gelaufen1() {
				}
			} else {
				if R.Geschoben1() {
				}
			}
		} else {
			if T == 2 {
				R.Markieren()
			} else {
				switch R.richtung {
				case Nord:
					R.umkehren()
				case West:
					R.LinksDrehen()
				case Sued:
					if T == 0 {
						if R.Gelaufen1() {
						}
					} else {
						for R.Gelaufen1() {
						}
					}
				case Ost:
					R.RechtsDrehen()
				}
			}
		}
	case kbd.Pos1:
		if !Sokoban {
			if R.Gemauert1() {
			}
		}
	case kbd.End:
		if !Sokoban {
			if R.Entmauert1() {
			}
		}
	case kbd.Tab:
		if !Sokoban {
			switch T {
			case 0:
				if Roboterwelt.markiert(R.Y, R.X) {
					R.Entmarkieren()
				} else {
					R.Markieren()
				}
				/*
				     R.Markieren ()
				   1: // unter X funktioniert Umschalt + Tab nicht
				     R.Entmarkieren ()
				   } else {
				     R.allesEntmarkieren ()
				*/
			}
		}
	case kbd.Ins:
		if !Sokoban {
			if R.tasche > 0 {
				R.Legen1()
			}
		}
	case kbd.Del:
		if !Sokoban {
			if T == 0 {
				R.Leeren1()
			} else {
				Roboterwelt.klotzen(R.Y, R.X, 0)
			}
		}
	case kbd.Back:
		for len(R.aktionen) > 0 {
			switch R.letzteAktion() {
			case Links:
				R.linksDrehenZurueck()
			case Rechts:
				R.rechtsDrehenZurueck()
			case Weiter:
				R.laufen1zurueck()
			case Zurueck:
				R.zuruecklaufen1zurueck()
			case KlotzWeg:
				R.leeren1zurueck()
			case KlotzHin:
				R.legen1zurueck()
			case KlotzWeiter:
				R.schieben1zurueck()
			case MarkeHin:
				R.markierenZurueck()
			case MarkeWeg:
				R.entmarkierenZurueck()
			case MauerHin:
				R.mauern1zurueck()
			case MauerWeg:
				R.entmauern1zurueck()
			}
			if T == 0 {
				break
			}
		}
	case kbd.Help:
		if Sokoban {
			errh.WriteHelp(Sokobanhilfe[:])
		} else {
			errh.WriteHelp(Hilfe[:])
		}
	case kbd.LookFor:
		// Roboter wechseln
	case kbd.Act:
		// neuen Roboter initialisieren
	case kbd.Cfg:
		// terminieren (R)
	case kbd.Mark:
		if !Sokoban {
			R.Markieren()
		}
	case kbd.Demark:
		if !Sokoban {
			if T == 0 {
				R.Entmarkieren()
			} else {
				R.allesEntmarkieren()
			}
		}
	case kbd.Paste:

	case kbd.Deposit:

	case kbd.Black:

	case kbd.Red:

	case kbd.Green:

	case kbd.Blue:

	case kbd.PrintScr:
		img.Print(0, 0, scr.NX(), scr.NY()-scr.NY1())
	case kbd.Roll:
		if T == 0 {
			// Roboter wechseln
		} else {
			// terminieren (R)
		}
	case kbd.Pause:
		// Roboter killen
	case kbd.Go:

		/*
		   case kbd.Here:
		     if scr.UnderMouse (2 * R.Y + 1, 4 * R.X, 4, 2) {
		       // ist angeklickt
		     }
		*/
	case kbd.Pull:
		// wenn Roboter getroffen, vorläufig hierhin
	case kbd.Hither:
		// wenn Roboter getroffen, endgültig hierhin
	case kbd.There:

	case kbd.Push:

	case kbd.Thither:

	case kbd.This:

	case kbd.Move:

	case kbd.Thus:

	case kbd.Navigate:

	}
	amEditieren = false
	schrittweise = s
}