Golang agent.Comm類代碼示例

func (self *RandomBot) Turn(comm agent.Comm) {
	defer func() { self.time += 1 }()

	if self.Time()%250 == 0 {
		x := pseudo_rand.Intn(2) - 1
		y := pseudo_rand.Intn(2) - 1
		comm.Move(x, y)
		self.log("info", "moved", x, y)
	}

	if self.Id() == 8 && self.Time() == 500 {
		self.send.Send([]byte("Hello there Number 1."), 1)
	}

	self.hello.Run(comm)
	self.route.Run(self.hello.Neighbors(), comm)
	m := self.send.Run(self.route.Routes(), comm)

	if m != nil {
		self.log("info", self.Time(), "got a message", string([]byte(m.Body())))
	}
	if self.Time()%100 == 9 {
		//         self.log("info", self.Time(), "neighbors", self.hello.Neighbors())

		//         self.log("info", self.Time(), "reachable", self.route.Reachable())
		//         s := fmt.Sprintf("\nRoute Table (%v):\n", self.agent.Id())
		//         for i := uint32(1); i <= 8; i++ {
		//             if route, has := self.routes[i]; has {
		//                 s += fmt.Sprint(route, "\n")
		//             }
		//         }
		//         self.log("info", s)
	}
}

func (self *Simple) Turn(comm agent.Comm) {
	if !comm.Move(agent.NewMove(1, 0)) {
		fmt.Println("Move Failed!")
	}
	if !comm.Move(agent.NewMove(1, 0)) {
		fmt.Println("Move Failed!")
	}
	return
}

func (self *SendMachine) send_message(comm agent.Comm) (sent, isack bool) {

	find := func() (*DataGram, bool) {
		for i := 0; i < self.sendq.Len(); i++ {
			msg, ok := self.sendq.Dequeue()
			if !ok {
				break
			}
			if _, has := self.routes[msg.DestAddr]; !has {
				self.sendq.Queue(msg)
			} else {
				return msg, true
			}
		}
		return nil, false
	}
	msg, found := find()
	if !found {
		return false, false
	}

	self.sendq.QueueFront(msg)

	next := self.routes[msg.DestAddr].NextAddr
	var pkt *Packet
	if msg.IsAck() {
		pkt = NewPacket(Commands["ACK"], self.agent.Id(), next)
	} else {
		pkt = NewPacket(Commands["MESSAGE"], self.agent.Id(), next)
	}
	pkt.SetBody(msg.Bytes())
	bytes := pkt.Bytes()
	comm.Broadcast(self.freq, bytes)
	if !msg.IsAck() {
		self.last_checksum = msg.ComputeChecksum()
	}
	self.last = bytes
	self.log("info", self.agent.Time(), "sent", pkt, msg)
	return true, msg.IsAck()
}

func (self *SendMachine) PerformListens(comm agent.Comm) *DataGram {
	switch self.state {
	case 1:
		return nil
	}
	pkt := MakePacket(comm.Listen(self.freq))
	if !pkt.ValidateChecksum() {
		return nil
	}
	ok, cmd, _ := pkt.Cmd()
	if !ok {
		return nil
	}
	switch cmd {
	case Commands["MESSAGE"]:
		myaddr := uint32(self.agent.Id())
		to := pkt.ToField()
		from := pkt.FromField()
		body := pkt.GetBody(PacketBodySize)
		self.qlog("heard", from, "sent to", to, "pkt", pkt, MakeDataGram(body))
		if to == myaddr {
			msg := MakeDataGram(body)
			if msg.ValidateChecksum() {
				ack := NewAckGram(msg.ComputeChecksum(), myaddr, from)
				self.sendq.QueueFront(ack)
				//                     ack_pkt := NewPacket(Commands["ACK"], myaddr, from)
				//                     ack_pkt.SetBody(ack.Bytes())
				//                     bytes := ack_pkt.Bytes()
				//                     comm.Broadcast(self.freq, bytes)
				if msg.DestAddr == myaddr {
					return msg
				}
				self.sendq.Queue(msg)
			}
		}
	}
	return nil
}

func (self *Configurable) Turn(comm agent.Comm) {
	broadcasted := comm.Broadcast(23, []byte("hello_world"))
	if self.LogBroadcast {
		comm.Log("Broadcast success:", broadcasted)
	}
	comm.Move(self.XVelocity, self.YVelocity)
	if self.LogMove {
		// comm.Logf("Pos: %v (%t)", self.Position(), success)
	}
	if self.LogListen {
		comm.Log("Heard:", string(comm.Listen(23)))
	}
	if self.LogCollect {
		comm.Log("Collected: ", comm.Collect())
	}
	if self.LogLook {
		comm.Log("Look: ", comm.Collect())
	}
	if self.LogPrevious {
		comm.Log("Previous: ", comm.PrevResult())
	}
	if self.LogEnergy {
		comm.Log("Energy:", comm.Energy())
	}
	return
}

func (self *SendMachine) confirm_acked(comm agent.Comm) (confirm bool) {

	cur := comm.Listen(self.freq)
	if self.last.Eq(cur) {
		self.qlog("heard my own packet")
		self.heard_last = true
		return false
	}

	if self.heard_last == false {
		self.wait -= 1
		if self.wait == 0 {
			self.state = 0
			self.backoff = self.backoff * (pseudo_rand.Float64()*2 + 1)
			self.wait = uint32(self.backoff)
			self.qlog("didn't hear last waiting...", self.wait)
		}
		return false
	}

	self.ack_wait -= 1
	if self.ack_wait == 0 {
		self.ack_backoff = self.ack_backoff * (pseudo_rand.Float64()*2 + 1)
		self.ack_wait = uint32(self.ack_backoff)
		self.state = 0
		return false
	}

	pkt := MakePacket(cur)
	if !pkt.ValidateChecksum() {
		return false
	}
	ok, cmd, _ := pkt.Cmd()
	if !ok {
		return false
	}
	self.log("info", self.agent.Time(), "got possible ack pkt", pkt)
	switch cmd {
	case Commands["ACK"]:
		self.log("info", self.agent.Time(), "it is an ack")
		myaddr := self.agent.Id()
		to := pkt.ToField()
		body := pkt.GetBody(PacketBodySize)
		self.log("info", self.agent.Time(), "it is to me?", myaddr, to)
		if to == myaddr {
			msg := MakeDataGram(body)
			self.log("info", self.agent.Time(), "the datagram", msg)
			if msg.ValidateChecksum() {
				self.log("info", self.agent.Time(), "it validates")
				self.log("info", self.agent.Time(), "it dest", msg.DestAddr, "myaddr", myaddr)
				if msg.DestAddr == myaddr {
					self.log("info", self.agent.Time(), "it dest == myaddr")
					bytes := msg.Body()[0:4]
					self.log("info", self.agent.Time(), "bytes", bytes, "last", self.last_checksum)
					if self.last_checksum.Eq(bytes) {
						return true
					}
				}
			}
		}
	}
	return false
}

func (self *SendMachine) confirm_last(comm agent.Comm) (confirm bool) {
	bytes := comm.Listen(self.freq)
	confirm = self.last.Eq(bytes)
	self.log("info", self.agent.Time(), "confirm_last", confirm)
	return
}