示例#1
0
func (g *Game) useAction(json consts.JsonType) consts.JsonType {
	res := utils.JsonAction("use", "badId")
	res["message"] = "some string"
	id, ok := utils.GetIdFromJson(json) //todo
	if ok {
		p := g.players.getPlayerBySession(json["sid"].(string))
		if *consts.FEATURE {
			if p.Killed() {
				return utils.JsonAction(res["action"].(string), "killed")
			}
		}
		xParam := json["x"]
		yParam := json["y"]
		res["result"] = "badSlot"
		if xParam != nil && yParam != nil {
			if item := p.GetItem(id); item != nil && item.IsWeapon() {
				if p.IsEquippedItem(item) {
					// if item.Get
					p.SetAttackPoint(xParam.(float64), yParam.(float64))
					res["message"] = fmt.Sprintf("attack point (%f, %f)", xParam.(float64), yParam.(float64))
					res["result"] = "ok"
				}
			}
		} else {
			p.UseItem(int64(json["id"].(float64)))
			res["result"] = "ok"
		}
	}
	return res
}
示例#2
0
func (g *Game) destroyItem(json consts.JsonType) consts.JsonType {
	res := utils.JsonAction("destroyItem", "badId")
	id, ok := utils.GetIdFromJson(json)
	if ok {
		item := g.items.getItem(id)
		p := g.players.getPlayerBySession(json["sid"].(string))
		if *consts.FEATURE {
			if p.Killed() {
				return utils.JsonAction(res["action"].(string), "killed")
			}
		}
		if item != nil && (item.IsOwner(p) || (!item.HasOwner() && geometry.Distance(p.GetCenter(), item.GetCenter()) <= consts.PICK_UP_RADIUS)) {
			var amount int = 1
			if json["amount"] != nil {
				amount = int(json["amount"].(float64))
			}
			// if item.GetAmount() - amount <= 0 {
			g.items.deleteItem(item)
			if item.IsOwner(p) {
				_, new_item := p.DeleteItem(item, amount)
				if new_item != nil {
					g.items.addItem(new_item)
				}
			} else if !item.HasOwner() {
				g.field.UnlinkFromCells(item)
			}
			// } else {
			//     item.DecAmount(amount)
			// }
			res["result"] = "ok"
		}
	}
	return res
}
示例#3
0
func (g *Game) dropItem(json consts.JsonType) consts.JsonType {
	res := utils.JsonAction("drop", "badId")
	id, ok := utils.GetIdFromJson(json)
	if ok {
		item := g.items.getItem(id)
		p := g.players.getPlayerBySession(json["sid"].(string))
		if *consts.FEATURE {
			if p.Killed() {
				return utils.JsonAction(res["action"].(string), "killed")
			}
		}
		if item != nil && item.IsOwner(p) {
			var amount int = 1
			if json["amount"] != nil {
				amount = int(json["amount"].(float64))
			}
			_, new_item := p.DropItem(item, amount)
			if new_item != nil {
				g.items.addItem(new_item)
			}
			g.field.LinkToCells(item)
			res["result"] = "ok"
		}
	}
	return res
}
示例#4
0
func (g *Game) pickUpItem(json consts.JsonType) consts.JsonType {
	res := utils.JsonAction("pickUp", "badId")
	id, ok := utils.GetIdFromJson(json)
	if ok {
		item := g.items.getItem(id)
		p := g.players.getPlayerBySession(json["sid"].(string))
		if *consts.FEATURE {
			if p.Killed() {
				return utils.JsonAction(res["action"].(string), "killed")
			}
		}
		if item != nil && !item.HasOwner() && geometry.Distance(p.GetCenter(), item.GetCenter()) <= float64(consts.PICK_UP_RADIUS) {
			if p.CanPickUp(item) {
				ok, i := p.PickUpItem(item)
				if ok {
					g.field.UnlinkFromCells(item)
					if item.GetID() != i.GetID() {
						g.items.deleteItem(item)
						item = nil
					}
					res["result"] = "ok"
				}
			} else {
				res["result"] = "tooHeavy"
			}
		}
	}
	return res
}
示例#5
0
func (g *Game) moveAction(json consts.JsonType) consts.JsonType {
	res := utils.JsonAction("move", "ok")
	p := g.players.getPlayerBySession(json["sid"].(string))
	if *consts.FEATURE {
		if p.Killed() {
			return utils.JsonAction(res["action"].(string), "killed")
		}
	}
	p.SetDir(consts.NameDirMapping[json["direction"].(string)])
	return res
}
示例#6
0
func (g *Game) setUpConstants(json consts.JsonType) consts.JsonType {
	res := utils.JsonAction("setUpConst", "badAction")
	if *consts.TEST && consts.TEST_MODE {
		var isValidConsts bool = true
		for name, _ := range consts.NameConstMapping {
			if json[name] != nil {
				_, ok := json[name].(float64)
				isValidConsts = isValidConsts && ok
			}
		}
		if isValidConsts {
			for name, constant := range consts.NameConstMapping {
				if json[name] != nil {
					if v, ok := constant.(*float64); ok {
						*v = json[name].(float64)
					} else if v, ok := constant.(*int); ok {
						*v = int(json[name].(float64))
					}
				}
			}
			consts.Refresh()
			res["result"] = "ok"
		}
	}
	return res
}
示例#7
0
func (g *Game) putItem(json consts.JsonType) consts.JsonType {
	res := utils.JsonAction("putItem", "badAction")
	if *consts.TEST && consts.TEST_MODE {
		var requiredFields = map[string]string{
			"x":    "badPlacing",
			"y":    "badPlacing",
			"item": "badItem",
		}
		var ok bool
		if ok, _ = utils.CheckJsonRequest(json, requiredFields); ok {
			itemDesc, ok1 := json["item"].(map[string]interface{})
			pt, isGoodPoint := utils.GetPointFromJson(json)
			if isGoodPoint && !g.field.IsBlocked(int(pt.X), int(pt.Y)) {
				res["result"] = "badInventory"
				if ok1 {
					item := gameObjectsBase.ItemFromJson(itemDesc)
					if item != nil {
						item.ForcePlace(*geometry.MakePoint(pt.X, pt.Y))
						g.items.addItem(item)
						g.field.LinkToCells(item)
						res["id"] = item.GetID()
						res["result"] = "ok"
					}
				}
			} else {
				res["result"] = "badPlacing"
			}
		}
	}
	return res
}
示例#8
0
func (g *Game) equipItem(json consts.JsonType) consts.JsonType {
	res := utils.JsonAction("equip", "badId")
	id, ok := utils.GetIdFromJson(json)
	if ok {
		json["action"] = "pickUp"
		g.doPlayersAction("pickUp", json)
		res["result"] = "badSlot"
		slotParam := json["slot"]
		if slotParam != nil {
			slot, isExistSlot := consts.NameSlotMapping[slotParam.(string)]
			if isExistSlot {
				p := g.players.getPlayerBySession(json["sid"].(string))
				item := p.GetItem(id)
				if item != nil {
					reason, slots := p.Equip(item, slot)
					if reason == consts.OK {
						if slots != nil {
							res["slots"] = slots
						}
						res["result"] = "ok"
					} else if reason == consts.BADID {
						res["result"] = "badId"
					} else if reason == consts.BADSLOT {
						res["result"] = "badSlot"
					}
				} else {
					res["result"] = "badId"
				}
			}
		}
	}
	fmt.Println(res)
	return res
}
示例#9
0
func (g *Game) lookAction(sid string) consts.JsonType {
	res := utils.JsonAction("look", "ok")
	player := g.players.getPlayerBySession(sid)
	if player == nil {
		return nil
	}
	visibleSpaceSide := 2*(consts.VISION_RADIUS) + 1 // check this plz
	//visibleSpaceSide := 2 * (consts.VISION_RADIUS + 1)
	px, py := int(player.Center.X), int(player.Center.Y)
	visibleSpace := make([][]string, visibleSpaceSide)
	visibleObjects := make([]consts.JsonType, 0, 1000)
	var addedObjects = map[int64]bool{player.GetID(): true}
	for i := 0; i < visibleSpaceSide; i++ {
		visibleSpace[i] = make([]string, visibleSpaceSide)
		for j := 0; j < visibleSpaceSide; j++ {
			fx, fy := px-consts.VISION_RADIUS+j, py-consts.VISION_RADIUS+i
			if fx > 0 && fy > 0 && fx < g.field.Width && fy < g.field.Height {
				visibleSpace[i][j] = string(g.field.GetBackground(fx, fy))
				for id, obj := range g.field.GetObjects(fx, fy) {
					if !addedObjects[id] {
						visibleObjects = append(visibleObjects, obj.GetInfo())
						addedObjects[id] = true
					}
				}
			} else {
				visibleSpace[i][j] = string(consts.WALL_SYMBOL)
			}
		}
	}
	/*l := int(math.Max(0.0, float64(px - consts.VISION_RADIUS)))
	  r := int(math.Min(float64(g.field.Width - 1), float64(px + consts.VISION_RADIUS)))
	  t := int(math.Max(0.0, float64(py - consts.VISION_RADIUS)))
	  b := int(math.Min(float64(g.field.Height - 1), float64(py + consts.VISION_RADIUS)))
	  for i := t; i <= b; i++ {
	      for j := l; j <= r; j++ {
	          visibleSpace[i - t][j - l] = string(g.field.GetBackground(j, i))
	      }
	  }*/
	res["map"] = visibleSpace
	/*visibleObjects := make([]consts.JsonType, 0, 1000)
	  var addedObjects = map[int64] bool {player.GetID() : true}
	  for i := t; i <= b; i++ {
	      for j := l; j <= r; j++ {
	          for id, obj := range g.field.GetObjects(j, i) {
	              if !addedObjects[id] {
	                  visibleObjects = append(visibleObjects,  obj.GetInfo())
	                  addedObjects[id] = true
	              }
	          }
	      }
	  }*/
	res["actors"] = visibleObjects
	res["x"] = player.Center.X
	res["y"] = player.Center.Y
	res["health"] = player.GetHP()
	res["cur_exp"] = player.GetExp()
	res["max_exp"] = player.GetMaxExp()
	return res
}
示例#10
0
func (g *Game) startTesting() consts.JsonType {
	res := utils.JsonAction("startTesting", "badAction")
	if *consts.TEST && !consts.TEST_MODE {
		consts.TEST_MODE = true
		res["result"] = "ok"
	}
	return res
}
示例#11
0
func (g *Game) useSkillAction(json consts.JsonType) consts.JsonType {
	res := utils.JsonAction("useSkill", "badPoint")
	x, ok1 := json["x"].(float64)
	y, ok2 := json["y"].(float64)
	if ok1 && ok2 {
		p := g.players.getPlayerBySession(json["sid"].(string))
		if *consts.FEATURE {
			if p.Killed() {
				return utils.JsonAction(res["action"].(string), "killed")
			}
		}
		start := p.GetCenter()
		damage := p.GetCharacteristic(consts.CHARACTERISTIC_INTELLEGENCE) * consts.FIREBALL_DAMAGE_MULTIPLIER
		g.projectileManager.NewFireBallProjectile(&start, geometry.MakePoint(x, y), damage, consts.FIREBALL_RADIUS, p)
		res["result"] = "ok"
	}
	return res
}
示例#12
0
func (g *Game) doPlayersAction(action string, json consts.JsonType) consts.JsonType {
	res := utils.JsonAction(action, "badSid")
	sid, ok := utils.GetSidFromJson(json)
	if ok {
		switch action {
		case "move":
			res = g.moveAction(json)
		case "use":
			res = g.useAction(json)
		case "getDictionary":
			res = g.getDictionaryAction()
		case "look":
			res = g.lookAction(sid)
		case "examine":
			res = g.examineAction(json)
		case "startTesting":
			res = g.startTesting()
		case "stopTesting":
			res = g.stopTesting(sid)
		case "setUpMap":
			res = g.setUpMap(json)
		case "pickUp":
			res = g.pickUpItem(json)
		case "drop":
			res = g.dropItem(json)
		case "destroyItem":
			res = g.destroyItem(json)
		case "equip":
			res = g.equipItem(json)
		case "unequip":
			res = g.unequipItem(json)
		case "moveItem":
			res = g.moveItem(json)
		case "getConst":
			res = g.getConstants()
		case "setUpConst":
			res = g.setUpConstants(json)
		case "putMob":
			res = g.putMob(json)
		case "putPlayer":
			res = g.putPlayer(json)
		case "putItem":
			res = g.putItem(json)
		case "enforce":
			res = g.enforceAction(json)
		case "setLocation":
			res = g.setLocationAction(json)
		case "useSkill":
			res = g.useSkillAction(json)
		case "revive":
			res = g.reviveAction(json)
		default:
			res = g.badAction(action)
		}
	}
	return res
}
示例#13
0
func (g *Game) getDictionaryAction() consts.JsonType {
	dict := make(consts.JsonType)
	for k, v := range g.dictionary {
		dict[k] = v
	}
	res := utils.JsonAction("getDictionary", "ok")
	res["dictionary"] = dict
	return res
}
示例#14
0
func (g *Game) setLocationAction(json consts.JsonType) consts.JsonType {
	res := utils.JsonAction("setLocation", "badPlacing")
	pt, ok := utils.GetPointFromJson(json)
	if ok {
		g.players.getPlayerBySession(json["sid"].(string)).ForcePlace(*pt)
		res["result"] = "ok"
	}
	return res
}
示例#15
0
func (g *Game) putMob(json consts.JsonType) consts.JsonType {
	res := utils.JsonAction("putMob", "badAction")
	if *consts.TEST && consts.TEST_MODE {
		var requiredFields = map[string]string{
			"x":           "badPlacing",
			"y":           "badPlacing",
			"flags":       "badFlag",
			"race":        "badRace",
			"dealtDamage": "badDamage",
		}
		var ok bool
		if ok, res["result"] = utils.CheckJsonRequest(json, requiredFields); ok {
			damage, ok := json["dealtDamage"].(string)
			if ok && utils.IsDiceDesc(damage) {
				flags := json["flags"].([]interface{})
				var stats = map[string]interface{}{}
				if json["stats"] != nil {
					stats, ok = json["stats"].(map[string]interface{})
					if !ok {
						res["result"] = "badStats"
					}
				}
				var inventory = map[string]interface{}{}
				if json["inventory"] != nil {
					inventory, ok = json["inventory"].(map[string]interface{})
					if !ok {
						res["result"] = "badInventory"
					}
				}
				pt, isGoodPoint := utils.GetPointFromJson(json)
				race, isExistRace := consts.NameRaceMapping[json["race"].(string)]
				if !(isGoodPoint && g.field.FreeForObject(pt.X, pt.Y)) {
					res["result"] = "badPlacing"
				} else if !gameObjectsFlags.CheckFlags(flags) {
					res["result"] = "badFlag"
				} else if !isExistRace {
					res["result"] = "badRace"
				} else {
					m := gameObjects.NewTestMob(pt.X, pt.Y, race, damage, flags)
					if !g.setCharacteristicsToActiveObject(m, stats) {
						res["result"] = "badStats"
						return res
					}
					if !g.setInventoryToActiveObject(m, inventory) {
						res["result"] = "badInventory"
						return res
					}
					res["id"] = g.mobs.registerMob(m)
					res["result"] = "ok"
				}
			} else {
				res["result"] = "badDamage"
			}
		}
	}
	return res
}
示例#16
0
func (g *Game) getConstants() consts.JsonType {
	res := utils.JsonAction("getConst", "badAction")
	if *consts.TEST && consts.TEST_MODE {
		for name, val := range consts.NameConstMapping {
			res[name] = val
		}
		res["result"] = "ok"
	}
	return res
}
示例#17
0
func (g *Game) setLocationAction(json consts.JsonType) consts.JsonType {
	res := utils.JsonAction("setLocation", "badPlacing")
	pt, ok := utils.GetPointFromJson(json)
	if ok {
		p := g.players.getPlayerBySession(json["sid"].(string))
		g.field.UnlinkFromCells(p)
		p.ForcePlace(*pt)
		g.field.LinkToCells(p)
		res["result"] = "ok"
	}
	return res
}
示例#18
0
func (g *Game) reviveAction(json consts.JsonType) consts.JsonType {
	res := utils.JsonAction("revive", "badAction")
	p := g.players.getPlayerBySession(json["sid"].(string))
	c := p.GetCenter()
	if *consts.FEATURE {
		if p.Killed() {
			res["result"] = "ok"
			g.field.UnlinkFromCells(p)
			x, y := g.newPlayerPos(c.X, c.Y)
			p.SetRevivePoint(x, y)
		}
	}
	return res
}
示例#19
0
func (g *Game) unequipItem(json consts.JsonType) consts.JsonType {
	res := utils.JsonAction("unequip", "badSlot")
	slotParam := json["slot"]
	if slotParam != nil {
		slot, isExistSlot := consts.NameSlotMapping[slotParam.(string)]
		if isExistSlot {
			p := g.players.getPlayerBySession(json["sid"].(string))
			if *consts.FEATURE {
				if p.Killed() {
					return utils.JsonAction(res["action"].(string), "killed")
				}
			}
			isUnequip, slots := p.Unequip(slot)
			if isUnequip {
				res["result"] = "ok"
				if slots != nil {
					res["slots"] = slots
				}
			}
		}
	}
	return res
}
示例#20
0
func (g *Game) moveItem(json consts.JsonType) consts.JsonType {
	res := utils.JsonAction("moveItem", "badId")
	idParam := json["id"]
	cellParam := json["cell"]
	if cellParam == nil {
		res["result"] = "badCell"
	} else if idParam != nil {
		cell := int(cellParam.(float64))
		p := g.players.getPlayerBySession(json["sid"].(string))
		if p.MoveItem(p.Inventory.GetItem(int64(idParam.(float64))), cell) {
			res["result"] = "ok"
		}
	}
	return res
}
示例#21
0
func (g *Game) enforceAction(json consts.JsonType) consts.JsonType {
	res := utils.JsonAction("enforce", "badAction")
	if *consts.TEST && consts.TEST_MODE {
		enforcedAction, ok := json["enforcedAction"].(map[string]interface{})
		if !ok {
			res["result"] = "badEnforcedAction"
		} else {
			res["result"] = "ok"
			action, ok := enforcedAction["action"].(string)
			if !ok {
				action = ""
			}
			res["actionResult"] = g.doPlayersAction(action, enforcedAction)
		}
	}
	return res
}
示例#22
0
func (g *Game) examineAction(json consts.JsonType) consts.JsonType {
	res := utils.JsonAction("examine", "badId")
	id, ok := utils.GetIdFromJson(json)
	if ok {
		obj, isExists := g.getObjectById(id)
		if isExists {
			for k, v := range obj.GetFullInfo() {
				res[k] = v
			}
			p := g.players.getPlayerById(id)
			if p != nil {
				res["inventory"] = p.GetInventoryInfo()
			}
			res["result"] = "ok"
		}
	}
	return res
}
示例#23
0
func (g *Game) stopTesting(sid string) consts.JsonType {
	res := utils.JsonAction("stopTesting", "badAction")
	if *consts.TEST && consts.TEST_MODE {
		for name, constant := range consts.NameConstMapping {
			if v, ok := constant.(*float64); ok {
				*v = consts.NameDefaultConstMapping[name].(float64)
			} else if v, ok := constant.(*int); ok {
				*v = consts.NameDefaultConstMapping[name].(int)
			} else {
				return res
			}
		}
		consts.TEST_MODE = false
		consts.SetDefaultConstantsValues()
		g.clearObjects(sid)
		g.field.Clear()
		res["result"] = "ok"
	}
	return res
}
示例#24
0
func (g *Game) setUpMap(json consts.JsonType) consts.JsonType {
	res := utils.JsonAction("setUpMap", "badAction")
	sid := json["sid"].(string)
	loadingFailed := func() consts.JsonType {
		res["result"] = "badMap"
		return res
	}
	if *consts.TEST && consts.TEST_MODE {
		var mapStrs []string
		data, ok := json["map"].([]interface{})
		if ok {
			for _, arr := range data {
				var str string
				chars, ok := arr.([]interface{})
				if ok {
					for _, el := range chars {
						char, ok := el.(string)
						if ok && g.inDictionary(char) {
							str += char
						} else {
							return loadingFailed()
						}
					}
				} else {
					return loadingFailed()
				}
				mapStrs = append(mapStrs, str)
			}
		} else {
			return loadingFailed()
		}

		if !g.field.LoadFromStrings(mapStrs) {
			return loadingFailed()
		}
		g.clearObjects(sid)
		res["result"] = "ok"
	}

	return res
}
示例#25
0
func (g *Game) lookAction(sid string) consts.JsonType {
	res := utils.JsonAction("look", "ok")
	player := g.players.getPlayerBySession(sid)
	if player == nil {
		return nil
	}
	YCount := consts.SCREEN_ROW_COUNT
	XCount := consts.SCREEN_COLUMN_COUNT
	YRad := (YCount - 1) / 2
	XRad := (XCount - 1) / 2
	px, py := int(player.Center.X), int(player.Center.Y)
	visibleSpace := make([][]string, YCount)
	visibleObjects := make([]consts.JsonType, 0, 1000)
	var addedObjects = map[int64]bool{player.GetID(): true}
	for i := 0; i < YCount; i++ {
		visibleSpace[i] = make([]string, XCount)
		for j := 0; j < XCount; j++ {
			fx, fy := px-XRad+j, py-YRad+i
			if fx > 0 && fy > 0 && fx < g.field.Width && fy < g.field.Height {
				visibleSpace[i][j] = string(g.field.GetBackground(fx, fy))
				for id, obj := range g.field.GetObjects(fx, fy) {
					if !addedObjects[id] {
						visibleObjects = append(visibleObjects, obj.GetInfo())
						addedObjects[id] = true
					}
				}
			} else {
				visibleSpace[i][j] = string(consts.WALL_SYMBOL)
			}
		}
	}
	res["map"] = visibleSpace
	res["actors"] = visibleObjects
	res["x"] = player.Center.X
	res["y"] = player.Center.Y
	res["health"] = player.GetHP()
	res["cur_exp"] = player.GetExp()
	res["max_exp"] = player.GetMaxExp()
	return res
}
示例#26
0
func (g *Game) moveAction(json consts.JsonType) consts.JsonType {
	res := utils.JsonAction("move", "ok")
	p := g.players.getPlayerBySession(json["sid"].(string))
	p.SetDir(consts.NameDirMapping[json["direction"].(string)])
	return res
}
示例#27
0
func (g *Game) badAction(action string) consts.JsonType {
	return utils.JsonAction(action, "badAction")
}
示例#28
0
func (g *Game) putPlayer(json consts.JsonType) consts.JsonType {
	res := utils.JsonAction("putPlayer", "badAction")
	if *consts.TEST && consts.TEST_MODE {
		var requiredFields = map[string]string{
			"x": "badPlacing",
			"y": "badPlacing",
			//"inventory" : "badInventory",
		}
		var ok bool
		if ok, res["result"] = utils.CheckJsonRequest(json, requiredFields); ok {
			inventory, ok := json["inventory"].([]interface{})
			var stats = map[string]interface{}{}
			if json["stats"] != nil {
				stats = json["stats"].(map[string]interface{})
			}
			pt, isGoodPoint := utils.GetPointFromJson(json)
			if !(isGoodPoint && g.field.FreeForObject(pt.X, pt.Y)) {
				res["result"] = "badPlacing"
			} else {
				var class int = consts.PLAYER_CLASS_WARRIOR
				if json["class"] != nil {
					var exists bool
					class, exists = consts.NamePlayerClassMapping[json["class"].(string)]
					if !exists {
						res["result"] = "badClass"
						return res
					}
				}
				p := gameObjects.NewPlayer(utils.GenerateId(), -1, class, "", utils.GenerateSID(), pt.X, pt.Y)
				g.setCharacteristicsToActiveObject(p, stats)
				g.players.add(p)
				g.field.LinkToCells(p)
				if ok {
					for _, itemDesc := range inventory {
						item := gameObjectsBase.ItemFromJson(consts.JsonType(itemDesc.(map[string]interface{})))
						if item != nil {
							g.items.addItem(item)
							p.PickUpItem(item)
						}
					}
					res["inventory"] = p.GetInventoryInfo()
				}
				if slots, okey := json["slots"].(map[string]interface{}); okey {
					idxs := make(map[string]int64)
					for slotName, itemDesc := range slots {
						if itemd, item_converted := itemDesc.(map[string]interface{}); item_converted {
							item := gameObjectsBase.ItemFromJson(consts.JsonType(itemd))
							if item != nil {
								p.PickUpItem(item)
								reason, _ := p.Equip(item, consts.NameSlotMapping[slotName])
								if reason == consts.OK {
									g.items.addItem(item)
									idxs[slotName] = item.GetID()
								} else if reason == consts.BADID {
									res["result"] = "badId"
									fmt.Println("wrong id")
									return res
								} else {
									res["result"] = "badSlot"
									fmt.Println("wrong slot")
									return res
								}
							}
						} else {
							fmt.Println("fail to convert")
							res["result"] = "badSlot"
							return res
						}
					}
					res["slots"] = idxs
				}
				res["sid"] = p.SID
				res["id"] = p.GetID()
				res["fistId"] = p.GetFistID()
				res["result"] = "ok"
			}
		}
	}
	return res
}
示例#29
0
func JsonHandler(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Access-Control-Allow-Origin", "*")

	w.Header().Set("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
	w.Header().Set("Access-Control-Allow-Headers", "Content-type")
	w.Header().Set("Content-type", "application/json")
	// w.Header().Set("Status Code", "200")
	if r.Method == "OPTIONS" {
		fmt.Fprintf(w, "OK")
		return
	}
	body, _ := ioutil.ReadAll(r.Body)
	var rawData interface{}
	json.Unmarshal(body, &rawData)
	data, ok2 := rawData.(map[string]interface{})
	if !ok2 {
		fmt.Println(data, rawData, r.Body)
	}
	var (
		action   string = data["action"].(string)
		response string
	)
	var requiredFields = map[string]string{}
	switch action {
	case "logout":
		requiredFields["sid"] = "badSid"
	case "login":
		requiredFields["login"] = "******"
		requiredFields["password"] = "******"
	case "register":
		requiredFields["login"] = "******"
		requiredFields["password"] = "******"
	}
	var ok bool
	res := utils.JsonAction(action, "badAction")
	if ok, res["result"] = utils.CheckJsonRequest(data, requiredFields); !ok {
		r, _ := json.Marshal(res)
		response = string(r)
	} else {
		switch action {
		case "startTesting":
			response = createResponse(action, "ok")
		case "logout":
			if sid, err := data["sid"].(string); err {
				response = logoutAction(sid)
			} else {
				response = createResponse(action, "badSid")
			}
		case "login":
			login, err1 := data["login"].(string)
			passwd, err2 := data["password"].(string)
			if err1 && err2 {
				response = loginAction(login, passwd)
			} else {
				response = createResponse(action, "invalidCredentials")
			}
		case "register":
			login, err1 := data["login"].(string)
			passwd, err2 := data["password"].(string)
			class, _ := data["class"].(string)
			if err1 && err2 {
				response = registerAction(login, passwd, class)
			} else if err1 {
				response = createResponse(action, "badLogin")
			} else if err2 {
				response = createResponse(action, "badPassword")
			}
		}
	}
	fmt.Fprintf(w, "%s", response)
}