Exemple #1
0
func (g *Game) clearDB() {
	var tables = []string{"users_inventory", "users_slots"}
	db := connect.CreateConnect()
	for _, table := range tables {
		db.Exec(fmt.Sprintf("DELETE FROM %s", table))
	}
}
Exemple #2
0
func (p *Player) Equip(item gameObjectsBase.Itemer, slotIota int) (int, consts.JsonType) {
	var res consts.JsonType = nil
	slot := p.slots[slotIota]
	if slot == nil || !slot.isSuitableType(item.GetItemType()) {
		return consts.BADSLOT, res
	}
	if item.GetItemClass() != consts.ITEM_CLASS_GARMENT || p.Equipped(item) {
		return consts.BADID, res
	}
	p.Unequip(slotIota)
	db := connect.CreateConnect()
	_, err := db.Exec("CALL equip_item(?, ?, ?, ?)", p.DBId, item.GetKindId(), item.EquipItem(p.Inventory), slotIota)
	if err == nil {
		if ok, s := p.getNearbySlot(slotIota, item.GetItemSubtype()); ok {
			if p.slots[s].item != nil && p.slots[s].item.GetID() != item.GetID() {
				p.Unequip(s)
			}
			res = consts.JsonType{}
			res[consts.SlotNameMapping[s]] = item.GetID()
			p.slots[s].item = nil
		} else {
			p.Unequip(slotIota)
		}
		slot.item = item
	}
	if err == nil {
		return consts.OK, res
	} else {
		return consts.BADID, res
	}
}
Exemple #3
0
func loginAction(login, pass string) string {
	result := map[string]interface{}{"result": "invalidCredentials"}
	if isExistUser(login, pass) {
		findSIDAndLogOut(login)
		db := connect.CreateConnect()
		sid := utils.GenerateSID()
		stmt, _ := db.Prepare("CALL add_user_session(?, ?)")
		defer stmt.Close()
		_, err := stmt.Exec(login, sid)
		if err == nil {
			host, _ := os.Hostname()
			//
			result["action"] = "login"
			//
			result["sid"] = sid
			result["result"] = "ok"
			result["webSocket"] = "ws://" + host + consts.SERVER_PORT + "/websocket"
			// result["webSocket"] = "ws://" + "192.168.173.230" + consts.SERVER_PORT + "/websocket"
			p := engine.GetInstance().CreatePlayer(sid)
			result["id"] = p.GetID()
			result["fistId"] = p.GetFistID()
		}
	}
	resJSON, _ := json.Marshal(result)
	return string(resJSON)
}
func (s *playerList) save() {
	db := connect.CreateConnect()
	defer db.Close()
	stmnt, _ := db.Prepare("UPDATE users_position SET x = ?, y = ? WHERE id = ?")
	defer stmnt.Close()
	for {
		for _, p := range s.players {
			stmnt.Exec(p.Center.X, p.Center.Y, p.DBId)
		}
		time.Sleep(consts.DATABASE_TICK_DURATION)
	}
}
Exemple #5
0
func (p *Player) DropItem(item gameObjectsBase.Itemer, amount int) (int, gameObjectsBase.Itemer) {
	db := connect.CreateConnect()
	place, new_item := p.ActiveObject.DropItem(item, amount)
	if s := p.getSlotByItem(item); s != consts.SLOT_DEFAULT {
		if item.GetAmount()-amount <= 0 {
			p.slots[s].item = nil
		}
		db.Exec("CALL dec_user_slot_amount(?, ?, ?, ?)", p.DBId, item.GetKindId(), s, amount)
	} else {
		db.Exec("CALL dec_user_item_amount(?, ?, ?, ?)", p.DBId, item.GetKindId(), place, amount)
	}
	return place, new_item
}
Exemple #6
0
func findSIDAndLogOut(login string) {
	var sid string
	db := connect.CreateConnect()
	stmt, _ := db.Prepare(`
        SELECT s.sid FROM sessions s
        INNER JOIN users u ON s.user_id = u.id
        WHERE u.login = ?
    `)
	defer stmt.Close()
	err := stmt.QueryRow(login).Scan(&sid)
	if err != sql.ErrNoRows {
		engine.GetInstance().LogoutPlayer(sid)
	}
}
Exemple #7
0
func logoutAction(u4 string) string {
	result := map[string]string{"result": "ok"}
	db := connect.CreateConnect()
	stmt, _ := db.Prepare("DELETE FROM sessions WHERE sid = ?")
	defer stmt.Close()
	res, _ := stmt.Exec(u4)
	if amount, _ := res.RowsAffected(); amount != 1 {
		result["result"] = "badSid"
	} else {
		engine.GetInstance().LogoutPlayer(u4)
	}
	resJSON, _ := json.Marshal(result)
	return string(resJSON)
}
Exemple #8
0
func (p *Player) PickUpItem(item gameObjectsBase.Itemer) (bool, gameObjectsBase.Itemer) {
	var err error = nil
	db := connect.CreateConnect()
	place, i := p.AddItem(item)
	if item.IsHeapItem() && place == -1 {
		_, err = db.Exec("CALL inc_user_slot_amount(?, ?, ?, ?)", p.DBId, item.GetKindId(), p.getSlotByItemType(item.GetItemType()), item.GetAmount())
	} else {
		_, err = db.Exec("CALL inc_user_item_amount(?, ?, ?, ?)", p.DBId, item.GetKindId(), place, item.GetAmount())
	}
	if err != nil {
		//
		fmt.Println(err)
	}
	return err == nil, i
}
Exemple #9
0
func (p *Player) MoveItem(item gameObjectsBase.Itemer, to_cell int) bool {
	if owner := item.GetOwner(); (owner != nil && owner.GetID() != p.GetID()) || p.Equipped(item) {
		return false
	}
	from_cell := p.Inventory.GetPlace(item.GetID())
	if from_cell == to_cell {
		return true
	} else {
		db := connect.CreateConnect()
		_, err := db.Exec("CALL move_item(?, ?, ?)", p.DBId, from_cell, to_cell)
		if err == nil {
			p.Inventory.MoveItem(item, from_cell, to_cell)
		}
		return err == nil
	}
}
Exemple #10
0
func isExistUser(login, pass string) bool {
	db := connect.CreateConnect()
	var (
		where   string = "login = ?"
		isLogin bool
	)
	if isLogin = pass != ""; isLogin {
		where = where + " AND password = ?"
	}
	stmt, _ := db.Prepare(connect.MakeSelect("users", where, "id"))
	defer stmt.Close()
	if isLogin {
		return stmt.QueryRow(login, pass).Scan() != sql.ErrNoRows
	} else {
		return stmt.QueryRow(login).Scan() != sql.ErrNoRows
	}
}
Exemple #11
0
func (ml *mobList) initializeMobTypes() consts.JsonType {
	blows.InitMobBlows()
	gameObjectsFlags.InitFlags(&GetInstance().field, GetInstance().msgsChannel)
	db := connect.CreateConnect()
	rows, _ := db.Query("SELECT name, base_hp, hp_inc, symbol, description, blow_method, flags, level_info FROM mobs_types")
	mobDictionary := make(consts.JsonType)
	for rows.Next() {
		var (
			base_hp                                                    int
			name, hp_inc, symbol, desc, flags, blowMethods, level_info string
		)
		rows.Scan(&name, &base_hp, &hp_inc, &symbol, &desc, &blowMethods, &flags, &level_info)
		depth := utils.ParseInt64(strings.Split(level_info, "|")[0])
		ml.mobsDepth[depth] = append(ml.mobsDepth[depth], gameObjects.CreateMobKind(name, base_hp, hp_inc, desc, blowMethods, flags))
		mobDictionary[symbol] = name
	}
	return mobDictionary
}
Exemple #12
0
func (g *Game) CreatePlayer(sid string) *gameObjects.Player {
	db := connect.CreateConnect()
	stmt, _ := db.Prepare(`
        SELECT u.id, u.login, u.class, up.x, up.y
        FROM users u
        INNER JOIN users_position as up ON u.id = up.user_id
        INNER JOIN sessions s ON s.user_id = u.id AND s.sid = ?
    `)
	defer stmt.Close()
	var dbId int64
	var login string
	var class int
	var x, y float64
	stmt.QueryRow(sid).Scan(&dbId, &login, &class, &x, &y)
	if x == consts.DEFAULT_PLAYER_POS_X || y == consts.DEFAULT_PLAYER_POS_Y {
		x, y = g.newPlayerPos(x, y)
	}
	p := gameObjects.NewPlayer(utils.GenerateId(), dbId, class, login, sid, x, y)
	g.players.add(p)
	g.field.LinkToCells(p)
	rows, _ := db.Query("SELECT item_id, amount, place FROM users_inventory WHERE user_id = ?", dbId)
	for rows.Next() {
		var (
			iid           int64
			amount, place int
		)
		rows.Scan(&iid, &amount, &place)
		item := gameObjectsBase.NewItemByID(iid, p, amount)
		p.RestoreItem(item, place)
		g.items.addItem(item)
	}
	rows, _ = db.Query("SELECT item_id, amount, slot FROM users_slots WHERE user_id = ?", dbId)
	for rows.Next() {
		var (
			iid          int64
			amount, slot int
		)
		rows.Scan(&iid, &amount, &slot)
		item := gameObjectsBase.NewItemByID(iid, p, amount)
		p.RestoreSlot(item, slot)
		g.items.addItem(item)
	}
	return p
}
Exemple #13
0
func (p *Player) DeleteItem(item gameObjectsBase.Itemer, amount int) (bool, gameObjectsBase.Itemer) {
	var (
		i   gameObjectsBase.Itemer = item
		res bool                   = false
	)
	db := connect.CreateConnect()
	var place int
	place, i = p.Inventory.DeleteItem(item, amount)
	if s := p.getSlotByItem(item); s != consts.SLOT_DEFAULT {
		if item.GetAmount() <= 0 {
			p.slots[s].item = nil
			i = nil
		}
		_, err := db.Exec("CALL dec_user_slot_amount(?, ?, ?, ?)", p.DBId, item.GetKindId(), s, amount)
		res = err == nil
	} else {
		_, err := db.Exec("CALL dec_user_item_amount(?, ?, ?, ?)", p.DBId, item.GetKindId(), place, amount)
		res = err == nil
	}
	return res, i
}
Exemple #14
0
func InitGameItems() {
	db := connect.CreateConnect()
	rows, _ := db.Query("SELECT id, name, atype, weight, allocation_info, power_info, message, description, bonus, effects FROM artifacts")
	for rows.Next() {
		var (
			id                                                                                        int64
			weight                                                                                    int
			atype_str, name, alloc_info_str, power_info_str, msg, desc, bonusesStr, effectsStr, power string
		)
		rows.Scan(&id, &name, &atype_str, &weight, &alloc_info_str, &power_info_str, &msg, &desc, &bonusesStr, &effectsStr)
		atype := strings.Split(atype_str, ":")
		power_arry := strings.Split(power_info_str, ":")
		if len(power_arry) > 1 {
			power = power_arry[1]
		}
		gameItems.items[id] = &ItemKind{id, name, weight, power, msg, desc, utils.ParseInt(atype[0]), utils.ParseInt(atype[1]), utils.ParseInt(atype[2]), make([]*Bonus, 0, 30), make([]Effecter, 0, 30)}
		alloc_info := strings.Split(alloc_info_str, ":")
		prob := utils.ParseInt(alloc_info[0])
		min_d := utils.ParseInt64(alloc_info[1]) - 1
		max_d := utils.ParseInt64(alloc_info[2]) - 1
		for i := min_d; i <= max_d; i++ {
			gameItems.items_depth_gen[i] = append(gameItems.items_depth_gen[i], &gameItemGen{gameItems.items[id], prob})
		}
		if len(bonusesStr) > 0 {
			for _, bonusStr := range strings.Split(bonusesStr, "@") {
				for _, bonus := range parseBonusFromDB(bonusStr) {
					gameItems.items[id].bonuses = append(gameItems.items[id].bonuses, bonus)
				}
			}
		}
		if len(effectsStr) > 0 {
			for _, effectStr := range strings.Split(effectsStr, "@") {
				for _, effect := range parseEffectFromDB(effectStr) {
					gameItems.items[id].effects = append(gameItems.items[id].effects, effect)
				}
			}
		}
	}
}
Exemple #15
0
func (p *Player) Unequip(slotIota int) (bool, consts.JsonType) {
	var res consts.JsonType = nil
	slot := p.slots[slotIota]
	if slot.item == nil {
		return false, res
	}
	db := connect.CreateConnect()
	k := slot.item.GetKindId()
	place := slot.item.UnequipItem(p.Inventory)
	_, err := db.Exec("CALL unequip_item(?, ?, ?, ?)", p.DBId, k, place, slotIota)
	if err == nil {
		if ok, s := p.getNearbySlot(slotIota, slot.item.GetItemSubtype()); ok {
			if p.slots[s].item != nil && p.slots[s].item.GetID() == slot.item.GetID() {
				res = consts.JsonType{}
				res[consts.SlotNameMapping[s]] = slot.item.GetID()
				p.slots[s].item = nil
			}
		}
		slot.item = nil
	}
	return err == nil, res
}
Exemple #16
0
func registerAction(login, pass, class string) string {
	result := map[string]string{"result": "ok"}
	class_numb, class_exists := consts.NamePlayerClassMapping[class]
	if !matchRegexp("^[a-zA-Z0-9]{2,36}$", login) {
		result["result"] = "badLogin"
	} else if !matchRegexp("^.{6,36}$", pass) {
		result["result"] = "badPassword"
	} else if isExistUser(login, "") {
		result["result"] = "loginExists"
	} else if !class_exists && class != "" {
		result["result"] = "badClass"
	} else {
		db := connect.CreateConnect()
		stmt, _ := db.Prepare("INSERT INTO users(login, password, class) VALUES(?, ?, ?)")
		defer stmt.Close()
		res, _ := stmt.Exec(login, pass, class_numb)
		user_id, _ := res.LastInsertId()
		stmt, _ = db.Prepare("INSERT INTO users_position(user_id, x, y) VALUES(?, ?, ?)")
		defer stmt.Close()
		stmt.Exec(user_id, consts.DEFAULT_PLAYER_POS_X, consts.DEFAULT_PLAYER_POS_Y)
	}
	resJSON, _ := json.Marshal(result)
	return string(resJSON)
}